decidim-term_customizer 0.16.6 → 0.17.0

data/lib/decidim/term_customizer/admin_engine.rb

@@ -10,7 +10,17 @@ module Decidim
 
       routes do
         resources :translation_sets, path: :sets, except: [:show] do
-          resources :translations, except: [:show]
+          member do
+            post :export
+          end
+
+          resources :translations, except: [:show] do
+            collection do
+              get :import, action: :new_import
+              post :import
+              resource :translations_destroy, only: [:new, :destroy]
+            end
+          end
           resources :add_translations, only: [:index, :create] do
             collection do
               get :search

data/lib/decidim/term_customizer/import.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    module Import
+      autoload :ImporterFactory, "decidim/term_customizer/import/importer_factory"
+      autoload :Importer, "decidim/term_customizer/import/importer"
+      autoload :Parser, "decidim/term_customizer/import/parser"
+      autoload :Readers, "decidim/term_customizer/import/readers"
+    end
+  end
+end

data/lib/decidim/term_customizer/import/importer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    module Import
+      # Class providing the interface and implementation of an importer. Needs
+      # a reader to be passed to the constructor which handles the import file
+      # reading depending on its type.
+      #
+      # You can also use the ImporterFactory class to create an Importer
+      # instance.
+      class Importer
+        # Public: Initializes an Importer.
+        #
+        # file   - A file with the data to be imported.
+        # reader - A Reader to be used to read the data from the file.
+        # parser - A Parser to be used during the import.
+        def initialize(file, reader = Readers::Base, parser = Parser)
+          @file = file
+          @reader = reader
+          @parser = parser
+        end
+
+        # Public: Imports a spreadsheet/JSON to the data collection provided by
+        # the parser. The parsed data objects are saved one by one or the data
+        # collection is yielded in case block is given in which case the saving
+        # should happen outside of this class.
+        def import
+          parser.resource_klass.transaction do
+            if block_given?
+              yield collection
+            else
+              collection.each(&:save!)
+            end
+          end
+        end
+
+        # Returns a data collection of the target data.
+        def collection
+          @collection ||= collection_data.map { |item| parser.new(item).parse }
+        end
+
+        private
+
+        attr_reader :file, :reader, :parser
+
+        def collection_data
+          return @collection_data if @collection_data
+
+          @collection_data = []
+          data_headers = []
+          reader.new(file).read_rows do |rowdata, index|
+            if index.zero?
+              data_headers = rowdata.map(&:to_sym)
+            else
+              @collection_data << Hash[
+                rowdata.each_with_index.map do |val, ind|
+                  [data_headers[ind], val]
+                end
+              ]
+            end
+          end
+
+          @collection_data
+        end
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/import/importer_factory.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    module Import
+      # A factory class providing easier way to create new importers.
+      class ImporterFactory
+        def self.build(file, mime_type, *args)
+          reader = Readers.find_by_mime_type(mime_type)
+          raise NotImplementedError, "No reader implemented for mime type: #{mime_type}" if reader.nil?
+
+          Importer.new(file, reader, *args)
+        end
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/import/parser.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    module Import
+      # This is an abstract class with a very naive default implementation
+      # for the importers to use. It can also serve as a superclass of your
+      # own implementation.
+      #
+      # It is used to be run against each element of an importable collection
+      # in order to parse relevant fields. Every import should specify their
+      # own parser or this default will be used.
+      class Parser
+        attr_reader :data
+
+        # Initializes the parser with a resource.
+        #
+        # data - The data hash to parse.
+        def initialize(data)
+          @data = data.except(:id, "id")
+        end
+
+        # Retuns the resource class to be created with the provided data.
+        def self.resource_klass
+          raise NotImplementedError, "#{self.class.name} does not define resource class"
+        end
+
+        # Can be used to convert the data hash to the resource attributes in
+        # case the data hash to be imported has different column names than the
+        # resource object to be created of it.
+        #
+        # By default returns the data hash but can be implemented by each parser
+        # implementation.
+        #
+        # Returns the resource attributes to be passed for the constructor.
+        def resource_attributes
+          @data
+        end
+
+        # Public: Returns a parsed object with the parsed data.
+        #
+        # Returns a target object.
+        def parse
+          self.class.resource_klass.new(resource_attributes)
+        end
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/import/readers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    module Import
+      module Readers
+        autoload :Base, "decidim/term_customizer/import/readers/base"
+        autoload :CSV, "decidim/term_customizer/import/readers/csv"
+        autoload :JSON, "decidim/term_customizer/import/readers/json"
+        autoload :XLS, "decidim/term_customizer/import/readers/xls"
+
+        # Accepted mime types
+        # keys: are used for dynamic help text on admin form.
+        # values: are used to validate the file format of imported document.
+        ACCEPTED_MIME_TYPES = {
+          json: Readers::JSON::MIME_TYPE,
+          csv: Readers::CSV::MIME_TYPE,
+          xls: Readers::XLS::MIME_TYPE
+        }.freeze
+
+        def self.all
+          [
+            Readers::CSV,
+            Readers::JSON,
+            Readers::XLS
+          ]
+        end
+
+        def self.find_by_mime_type(mime_type)
+          all.each do |reader_klass|
+            return reader_klass if mime_type == reader_klass::MIME_TYPE
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/import/readers/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    module Import
+      module Readers
+        # Imports an exported file to data arrays that can be processed during
+        # yields.
+        class Base
+          def initialize(file)
+            @file = file
+          end
+
+          # The read_rows method should iterate over each row of the data and
+          # yield the data array of each row with the row's index. For example,
+          # this could look like following:
+          #   Parser.read(file).rows.each_with_index do |row, index|
+          #     yield row.to_a, index
+          #   end
+          #
+          # The first row yielded with index 0 needs to contain the data headers
+          # which can be later used to map the data to correct attributes.
+          #
+          # This needs to be implemented by the extending classes.
+          def read_rows
+            raise NotImplementedError
+          end
+
+          protected
+
+          attr_reader :file
+        end
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/import/readers/csv.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Decidim
+  module TermCustomizer
+    module Import
+      module Readers
+        # Imports any exported CSV file to local objects. It transforms the
+        # import data using the parser into the final target objects.
+        class CSV < Base
+          MIME_TYPE = "text/csv"
+
+          def read_rows
+            ::CSV.read(file, col_sep: ";").each_with_index do |row, index|
+              yield row, index
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/import/readers/json.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Decidim
+  module TermCustomizer
+    module Import
+      module Readers
+        # Imports any exported JSON file to local objects. It transforms the
+        # import data using the parser into the final target objects.
+        class JSON < Base
+          MIME_TYPE = "application/json"
+
+          def read_rows
+            json_string = File.read(file)
+            ::JSON.parse(json_string).each_with_index do |row, index|
+              yield row.keys, index if index.zero?
+              yield row.values, index + 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/import/readers/xls.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "spreadsheet"
+
+module Decidim
+  module TermCustomizer
+    module Import
+      module Readers
+        # Imports any exported XLS file to local objects. It transforms the
+        # import data using the parser into the final target objects.
+        class XLS < Base
+          MIME_TYPE = "application/vnd.ms-excel"
+
+          def read_rows
+            book = ::Spreadsheet.open(file)
+            sheet = book.worksheet(0)
+            sheet.each_with_index do |row, index|
+              yield row.to_a, index
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/translation_import_collection.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    class TranslationImportCollection
+      def initialize(translation_set, records, locales)
+        @translation_set = translation_set
+        @records = records
+        @locales = locales
+      end
+
+      def import_attributes
+        attributes_for_all_locales
+      end
+
+      private
+
+      attr_reader :translation_set, :records, :locales
+
+      def collection_attributes
+        @collection_attributes ||= records.map do |translation|
+          # Skip all translation keys that already exists
+          next if translation_set.translations.where(
+            key: translation.key
+          ).present?
+
+          {
+            locale: translation.locale,
+            key: translation.key,
+            value: translation.value
+          }
+        end.compact
+      end
+
+      def unique_attributes
+        @unique_attributes ||= collection_attributes.uniq do |attr|
+          "#{attr[:locale]}.#{attr[:key]}"
+        end
+      end
+
+      def attribute_keys
+        @attribute_keys ||= unique_attributes.map { |attr| attr[:key] }.uniq
+      end
+
+      def attributes_for_all_locales
+        @attributes_for_all_locales ||= attribute_keys.map do |key|
+          locales.map do |locale|
+            # Find if the item with the locale already exists in the
+            # unique collection.
+            item = unique_attributes.find do |attr|
+              attr[:key] == key && attr[:locale] == locale.to_s
+            end
+
+            # In case the item does not exist for the key and locale, create
+            # a new item with the default I18n translation. Otherwise, return
+            # the found item to the final array.
+            if item.nil?
+              {
+                key: key,
+                locale: locale.to_s,
+                value: I18n.t(key, locale: locale, default: "")
+              }
+            else
+              item
+            end
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/translation_parser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    # This class serializes a Proposal so can be exported to CSV, JSON or other
+    # formats.
+    class TranslationParser < Import::Parser
+      def self.resource_klass
+        Decidim::TermCustomizer::Translation
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/translation_serializer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    # This class serializes a Proposal so can be exported to CSV, JSON or other
+    # formats.
+    class TranslationSerializer < Decidim::Exporters::Serializer
+      # Public: Initializes the serializer with a proposal.
+      def initialize(translation)
+        @translation = translation
+      end
+
+      # Public: Exports a hash with the serialized data for this proposal.
+      def serialize
+        {
+          id: translation.id,
+          locale: translation.locale,
+          key: translation.key,
+          value: translation.value
+        }
+      end
+
+      private
+
+      attr_reader :translation
+    end
+  end
+end