csv_import_magic 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9762b760d0c38be416b68d85d09947ca989f9a6c9a0b6a491a00a863eff1264d
-  data.tar.gz: 43121c1a1362b1aa3f610788c2ee41bb8c78968c1a790170adcd0ade5f0171fd
+  metadata.gz: 1799c22d5a948f93d5013652d3f41332ed0e7d4130ff4ec9331bfed2c3c25010
+  data.tar.gz: fe0b788051da284c8bbe28f5eac7ccdb5dbb52a48d40be91140b8e213dfc27f8
 SHA512:
-  metadata.gz: ca0a7d516a837d9ae0c44d314da3d4124e75216d1f74b245de3bb1c0492e00381db964f49e96a470cdc72280fd1de17597420ab06e988b0e2639a539a7ad3782
-  data.tar.gz: 63d21de87b9de6d5b7d73134aa47885551b8aa3fb37a6be711fb8a345f23bec4730c085209d6de95b23a0fc40f2ac2f3c9fb7adbb2e4402c0d1d1e8547f598f4
+  metadata.gz: 75a8feba8f45cc3ff7599311b8b264dc518ba74f2b4a8382d210543a4b7c7a37f889b4762c368c34c713dd96b641f209126c7c4981638855f6766cdc04bbd7ed
+  data.tar.gz: 2738b662407d5c0b80e11442e8a79d7cc743f62e282cc83995e15e510c9197ab837fb7a39b7596fb3f69b7fcb3b2bb3301a439f09bb28aa97460aab9a841da63

data/app/controllers/csv_import_magic/importers_controller.rb

@@ -2,23 +2,56 @@ module CsvImportMagic
   class ImportersController < CsvImportMagic::BaseController
     helper_method :import_file_csv
     layout 'csv_import_magic'
+    respond_to :html, :json
 
     def show
       @importer = ::Importer.find(params[:id])
+
+      respond_with do |format|
+        format.html
+        format.json do
+          render json: {
+            importer: @importer,
+            attachment_error_url: @importer&.attachment_error&.url,
+          } 
+        end
+      end
     end
 
     def create
       @importer = ::Importer.new(importer_params)
 
       if @importer.save! && import_file_csv
-        redirect_to edit_importer_path(@importer), alert: t('csv_import_magic.importers_controller.create.alert')
+        respond_with do |format|
+          format.html { redirect_to edit_importer_path(@importer), alert: t('csv_import_magic.importers_controller.create.alert') }
+          format.json do 
+            render json: {
+              columns: @importer.importable_columns(@importer.parser).map { |column| [@importer.human_attribute_name(column), column] }.unshift([t('csv_import_magic.views.importers.edit.ignore_column_label'), :ignore]),
+              data: import_file_csv.first(5).map(&:to_hash),
+              importer: @importer
+            }
+          end
+        end
       end
     rescue ActiveRecord::RecordInvalid, CSV::MalformedCSVError => e
-      redirect_back fallback_location: '/', flash: { error: e.message }
+      respond_with do |format|
+        format.html { redirect_back fallback_location: '/', flash: { error: e.message } }
+        format.json { render json: { error: e.message }, status: :unprocessable_entity }
+      end
     end
 
     def edit
       @importer = ::Importer.find(params[:id])
+
+      respond_with do |format|
+        format.html
+        format.json { render json: @importer }
+      end
+    rescue ActiveRecord::RecordNotFound
+      respond_with do |format|
+        format.html
+        format.json { render json: { error: 'importer not found' }, status: :unprocessable_entity }
+      end
     end
 
     def update
@@ -26,11 +59,21 @@ module CsvImportMagic
 
       if @importer.update(csv_importer_magic_update_params)
         CsvImportMagic::ImporterWorker.perform_async(importer_id: @importer.id, resources: resources)
-        redirect_to importer_path(@importer), flash: { notice: t('csv_import_magic.importers_controller.update.notice') }
+
+        respond_with do |format|
+          format.html { redirect_to importer_path(@importer), flash: { notice: t('csv_import_magic.importers_controller.update.notice') } }
+          format.json { render json: @importer }
+        end
       else
         errors = @importer.errors.full_messages.to_sentence
-        flash[:alert] = errors.present? ? errors : t('csv_import_magic.importers_controller.update.alert')
-        render :edit
+        
+        respond_with do |format|
+          format.html do 
+            flash[:alert] = errors.present? ? errors : t('csv_import_magic.importers_controller.update.alert')
+            render :edit
+          end
+          format.json { render json: { error: errors.present? ? errors : t('csv_import_magic.importers_controller.update.alert') }, status: :unprocessable_entity }
+        end
       end
     end
 
@@ -60,7 +103,7 @@ module CsvImportMagic
     end
 
     def importer_params
-      params.require(:importer).permit!
+      params.require(:importer).permit(:source, :attachment, :importable_type, :importable_id, :parser)
     end
 
     def csv_importer_magic_update_params

data/lib/csv_import_magic/version.rb

@@ -1,3 +1,3 @@
 module CsvImportMagic
-  VERSION = '0.0.11'.freeze
+  VERSION = '0.0.12'.freeze
 end

data/spec/controllers/csv_import_magic/importers_controller_spec.rb

@@ -4,8 +4,15 @@ RSpec.describe CsvImportMagic::ImportersController, type: :controller do
   routes { CsvImportMagic::Engine.routes }
 
   describe 'POST #create' do
-    def do_action
-      post :create, params: { importer: { attachment: attachment, importable_type: 'User', importable_id: create(:user).id, source: 'company' } }
+    def do_action(format = :html)
+      post :create, params: { 
+        importer: { 
+          attachment: attachment,
+          importable_type: 'User',
+          importable_id: create(:user).id,
+          source: 'company' 
+        } 
+      }, format: format
     end
 
     context 'with valid params' do
@@ -15,22 +22,45 @@ RSpec.describe CsvImportMagic::ImportersController, type: :controller do
         expect { do_action }.to change(Importer, :count).by(1)
       end
 
-      it 'redirect to edit' do
-        do_action
-        import = Importer.last
-        expect(response).to redirect_to(edit_importer_path(import.id))
-        expect(flash[:alert]).to eq('Por favor, informe em quais colunas podemos encontrar as informações que você deseja.')
+      context 'respond to html' do
+        it 'redirect to edit' do
+          do_action
+          import = Importer.last
+          expect(response).to redirect_to(edit_importer_path(import.id))
+          expect(flash[:alert]).to eq('Por favor, informe em quais colunas podemos encontrar as informações que você deseja.')
+        end
+      end
+
+      context 'respond to json' do
+        it 'return the importer' do
+          do_action(:json)
+          import = Importer.last
+          expect(response).to be_successful
+          expect(JSON.parse(response.body)).to include('importer' => include('id' => import.id))
+          expect(JSON.parse(response.body)).to include('columns' => include(['Ignorar esta coluna', 'ignore'], ['Nome', 'name'], ['Rua', 'street'], ['Numero', 'number'], ['Bairro', 'neighborhood'], ['Cidade', 'city'], ['Estado', 'state'], ['Pais', 'country']))
+          expect(JSON.parse(response.body)).to include('data' => include(a_hash_including('bairro' => 'Joao de Barro', 'cidade ' => 'Birigui', 'estado ' => 'SP ', 'nome' => 'foo', 'numero' => '1', 'pais' => 'Brasil', 'rua' => 'R: Teste')))
+        end
       end
     end
 
     context 'with invalid params' do
       let(:attachment) { nil }
 
-      it 'render to edit with error' do
-        @request.env['HTTP_REFERER'] = 'http://example.com'
-        do_action
-        expect(response).to redirect_to('http://example.com')
-        expect(flash[:error]).to eq('A validação falhou: Anexo CSV não pode ficar em branco')
+      context 'respond to html' do
+        it 'render to edit with error' do
+          @request.env['HTTP_REFERER'] = 'http://example.com'
+          do_action
+          expect(response).to redirect_to('http://example.com')
+          expect(flash[:error]).to eq('A validação falhou: Anexo CSV não pode ficar em branco')
+        end
+      end
+
+      context 'respond to json' do
+        it 'return the error' do
+          do_action(:json)
+          expect(response).to have_http_status(:unprocessable_entity)
+          expect(JSON.parse(response.body)).to include('error' => 'A validação falhou: Anexo CSV não pode ficar em branco')
+        end
       end
     end
   end
@@ -38,68 +68,108 @@ RSpec.describe CsvImportMagic::ImportersController, type: :controller do
   describe 'GET #show' do
     let(:importer) { create :importer }
 
-    def do_action
-      get :show, params: { id: importer.id }
+    def do_action(format = :html)
+      get :show, params: { id: importer.id }, format: format
     end
 
-    before { do_action }
+    context 'respond to html' do
+      it 'return OK' do
+        do_action
+        is_expected.to respond_with(:success)
+        is_expected.to render_template(:show)
+        expect(assigns(:importer)).to eq(importer)
+      end
+    end
 
-    it 'return OK' do
-      is_expected.to respond_with(:success)
-      is_expected.to render_template(:show)
-      expect(assigns(:importer)).to eq(importer)
+    context 'respond to json' do
+      it 'return the importer' do
+        do_action(:json)
+        get :show, params: { id: importer.id }, format: :json
+        expect(response).to be_successful
+        expect(JSON.parse(response.body)).to have_key('importer')
+        expect(JSON.parse(response.body)).to have_key('attachment_error_url')
+      end
     end
   end
 
   describe 'GET #edit' do
     let(:importer) { create :importer }
 
-    def do_action
-      get :edit, params: { id: importer.id }
+    def do_action(format = :html)
+      get :edit, params: { id: importer.id }, format: format
     end
 
-    before { do_action }
+    context 'respond to html' do
+      it 'return OK' do
+        do_action
+        is_expected.to respond_with(:success)
+        is_expected.to render_template(:edit)
+        expect(assigns(:importer)).to eq(importer)
+        expect(controller.send(:import_file_csv).headers).to match_array(['bairro', 'cidade ', 'cod', 'estado ', 'nome', 'numero', 'pais', 'rua'])
+      end
+    end
 
-    it 'return OK' do
-      is_expected.to respond_with(:success)
-      is_expected.to render_template(:edit)
-      expect(assigns(:importer)).to eq(importer)
-      expect(controller.send(:import_file_csv).headers).to match_array(['bairro', 'cidade ', 'cod', 'estado ', 'nome', 'numero', 'pais', 'rua'])
+    context 'respond to json' do
+      it 'return the importer' do
+        do_action(:json)
+        expect(response).to be_successful
+        expect(JSON.parse(response.body)).to include('id' => importer.id)
+      end
     end
   end
 
   describe 'PUT #update' do
     let(:importer) { create :importer, columns: [] }
 
-    def do_action(columns)
-      put :update, params: { id: importer.id, importer: { columns: columns } }
+    def do_action(columns, format = :html)
+      put :update, params: { id: importer.id, importer: { columns: columns } }, format: format
     end
 
-    context 'with valid columns' do
-      it 'update the importer columns list' do
-        do_action(%w(neighborhood city cod state name number country street))
-        expect(importer.reload.columns).to eq(%w(neighborhood city cod state name number country street))
+    context 'respond to html' do
+      context 'with valid columns' do
+        it 'update the importer columns list' do
+          do_action(%w(neighborhood city cod state name number country street))
+          expect(importer.reload.columns).to eq(%w(neighborhood city cod state name number country street))
+        end
+
+        it 'redirect back to employees index' do
+          do_action(%w(neighborhood city cod state name number country street))
+          expect(response).to redirect_to(importer_path(importer))
+          expect(flash[:notice]).to eq('Arquivo enviado para processamento.')
+        end
+
+        it 'enqueue the Importer::EmployeesCSVWorker' do
+          expect(CsvImportMagic::ImporterWorker).to receive(:perform_async).with(importer_id: importer.id, resources: nil)
+          do_action(%w(neighborhood city cod state name number country street))
+        end
       end
 
-      it 'redirect back to employees index' do
-        do_action(%w(neighborhood city cod state name number country street))
-        expect(response).to redirect_to(importer_path(importer))
-        expect(flash[:notice]).to eq('Arquivo enviado para processamento.')
+      context 'with invalid columns' do
+        it 'render the edit screen' do
+          do_action(%w(neighborhood city cod state name name number country street))
+          is_expected.to respond_with(:success)
+          is_expected.to render_template(:edit)
+          expect(assigns(:importer)).to eq(importer)
+          expect(flash[:alert]).to eq('Colunas Nome deve ser única')
+        end
       end
+    end
 
-      it 'enqueue the Importer::EmployeesCSVWorker' do
-        expect(CsvImportMagic::ImporterWorker).to receive(:perform_async).with(importer_id: importer.id, resources: nil)
-        do_action(%w(neighborhood city cod state name number country street))
+    context 'respond to json' do
+      context 'with valid columns' do
+        it 'return the importer' do
+          do_action(%w(neighborhood city cod state name number country street), :json)
+          expect(response).to be_successful
+          expect(JSON.parse(response.body)).to include('id' => importer.id)
+        end
       end
-    end
 
-    context 'with invalid columns' do
-      it 'render the edit screen' do
-        do_action(%w(neighborhood city cod state name name number country street))
-        is_expected.to respond_with(:success)
-        is_expected.to render_template(:edit)
-        expect(assigns(:importer)).to eq(importer)
-        expect(flash[:alert]).to eq('Colunas Nome deve ser única')
+      context 'with invalid columns' do
+        it 'return the error' do
+          do_action(%w(neighborhood city cod state name name number country street), :json)
+          expect(response).to have_http_status(:unprocessable_entity)
+          expect(JSON.parse(response.body)).to include('error' => 'Colunas Nome deve ser única')
+        end
       end
     end
   end