pg_rails 7.0.8.pre.alpha.56 → 7.0.8.pre.alpha.58

data/pg_engine/lib/pg_engine/email_observer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module PgEngine
+  class EmailObserver
+    def self.delivered_email(message)
+      # content = get_content(message)
+      # subject = message.subject
+
+      # message.to puede ser un string o un array de strings
+      # to = [message.to].flatten.join(', ')
+
+      message_id = message.message_id
+      mailer = message.delivery_handler.to_s
+      status = get_status(message)
+      return if message['email'].blank?
+
+      # El objeto Email ya estaba creado. Agarro ese objeto y le actualizo las cosas
+      email = message['email'].unparsed_value
+
+      email.encoded_eml.attach({ io: StringIO.new(message.encoded), filename: "email-#{email.id}.eml" })
+
+      email.update_columns(message_id:, mailer:, status:) # rubocop:disable Rails/SkipsModelValidations
+      # else
+      # TODO: crear email
+      # pg_warn 'El mail no tenía objeto Email asociado, se creó uno on the fly.', :warn
+      # # No hay objeto Email, entonces le creo uno para que quede logueado.
+      # # TODO: el content puede ser TXT
+      # Email.create!(message_id: message.message_id, body_html: message.encoded,
+      # subject: subject, recipient: recipient,
+      #               date: DateTime.now, mailer: message.delivery_handler.to_s, associated: associated(message),
+      #               status: get_status(message), observations: get_observations(message))
+    end
+
+    def self.get_status(message)
+      message.perform_deliveries ? :sent : :blocked
+    end
+
+    # def self.get_html_or_text(message)
+    #   message.body.parts.find { |p| p.content_type.match(/multipart/).present? }
+    #   part = message.body.parts.find { |p| p.content_type.match(/html/).present? }
+    #   part = message.body.parts.find { |p| p.content_type.match(/text/).present? } if part.nil?
+    #   part = message if part.nil?
+    #   part.body.raw_source
+    # end
+
+    # def self.associated(message)
+    #   return if message['associated'].blank?
+
+    #   message['associated'].unparsed_value
+    # end
+
+    # def self.get_observations(message)
+    #   return if message['observations'].blank?
+
+    #   message['observations'].unparsed_value
+    # end
+
+    # def self.get_content(message)
+    #   multipart = message.body.parts.find { |p| p.content_type.match(/multipart/).present? }
+    #   part = multipart.presence || message
+    #   get_html_or_text(part)
+    # rescue StandardError => e
+    #   pg_err e
+    #   ''
+    # end
+  end
+end

data/pg_engine/lib/pg_engine/mailgun/log_sync.rb

@@ -0,0 +1,71 @@
+require 'fileutils'
+require 'mailgun'
+require 'active_support'
+require 'active_support/core_ext/numeric/time'
+require 'json'
+
+module PgEngine
+  module Mailgun
+    class LogSync
+      def self.download # rubocop:disable Metrics/AbcSize
+        domain = ENV.fetch('MAILGUN_DOMAIN')
+
+        key = Rails.application.credentials.dig(:mailgun, :api_key)
+        mg_client = ::Mailgun::Client.new(key)
+        items = []
+        end_time = DateTime.now
+        start_time = DateTime.now - 3.days
+        range = 1.day
+        current = end_time - range
+        loop do
+          get = "#{domain}/events?begin=#{current.to_i}&end=#{(current + range).to_i}&limit=300"
+          result = mg_client.get(get)
+          result.to_h!
+          items.push(result.body['items'])
+          # puts "Current: #{current}. Items count: #{result.body['items'].length}"
+          current -= range
+
+          break if current < start_time
+        end
+
+        FileUtils.mkdir_p(dir)
+
+        File.write("#{dir}/#{domain}-#{Time.zone.now.strftime('%Y-%m-%d_%H.%M.%S')}.json", items.flatten.to_json)
+      end
+
+      def self.dir
+        @dir ||= if Rails.env.test?
+                   File.expand_path 'tmp/mailgun_logs', Rails.root
+                 else
+                   File.expand_path 'log/mailgun_logs', Rails.root
+                 end
+      end
+
+      def self.sync_redis
+        json = []
+        Dir["#{dir}/*.json"].each do |file|
+          json.push(*JSON.parse(File.read(file)))
+        end
+
+        json.each do |i|
+          # [
+          #   Time.at(i["timestamp"]).strftime('%y-%m-%d %H:%M %z'),
+          #   i["message"]["headers"]["message-id"],
+          #   # i["message"]["headers"]["message-id"][3..15],
+          #   i["event"],
+          #   i["recipient"],
+          #   i["message"]["headers"]["from"],
+          #   i["message"]["headers"]["subject"],
+          # ]
+          message_id = i['message']['headers']['message-id']
+          email = Email.where(message_id:).first
+          if email
+            email.logs << i.to_json
+          else
+            pg_warn "No existe el mail con message_id = #{message_id}", :warn
+          end
+        end
+      end
+    end
+  end
+end

data/pg_engine/lib/pg_engine.rb

@@ -4,6 +4,8 @@ require_relative 'pg_engine/engine'
 require_relative 'pg_engine/core_ext'
 require_relative 'pg_engine/error'
 require_relative 'pg_engine/configuracion'
+require_relative 'pg_engine/email_observer'
+require_relative 'pg_engine/mailgun/log_sync'
 require_relative 'pg_engine/route_helpers'
 require_relative 'pg_engine/utils/pg_logger'
 require_relative 'pg_engine/utils/pdf_preview_generator'
@@ -45,6 +47,8 @@ require 'sassc'
 require 'image_processing'
 require 'hashid/rails'
 require 'redis'
+require 'kredis'
+require 'mailgun-ruby'
 
 if Rails.env.local?
   require 'letter_opener'

data/pg_engine/spec/controllers/admin/emails_controller_spec.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+# generado con pg_rails
+
+require 'rails_helper'
+
+# This spec was generated by rspec-rails when you ran the scaffold generator.
+# It demonstrates how one might use RSpec to specify the controller code that
+# was generated by Rails when you ran the scaffold generator.
+#
+# It assumes that the implementation code is generated by the rails scaffold
+# generator.  If you are using any extension libraries to generate different
+# controller code, this generated spec may or may not pass.
+#
+# It only uses APIs available in rails and/or rspec-rails.  There are a number
+# of tools you can use to make these specs even more expressive, but we're
+# sticking to rails and rspec-rails APIs to keep things simple and stable.
+#
+# Compared to earlier versions of this generator, there is very limited use of
+# stubs and message expectations in this spec.  Stubs are only used when there
+# is no simpler way to get a handle on the object needed for the example.
+# Message expectations are only used when there is no simpler way to specify
+# that an instance is receiving a specific message.
+#
+# Also compared to earlier versions of this generator, there are no longer any
+# expectations of assigns and templates rendered. These features have been
+# removed from Rails core in Rails 5, but can be added back in via the
+# `rails-controller-testing` gem.
+
+RSpec.describe Admin::EmailsController do
+  render_views
+  # This should return the minimal set of attributes required to create a valid
+  # Email. As you add validations to Email, be sure to
+  # adjust the attributes here as well.
+  let(:valid_attributes) do
+    attributes_for(:email)
+  end
+
+  let(:invalid_attributes) do
+    {
+      from_address: nil
+    }
+  end
+
+  let(:logged_user) { create :user, :developer }
+
+  before do
+    sign_in logged_user if logged_user.present?
+  end
+
+  describe 'routing' do
+    it 'routes GET index correctly' do
+      route = { get: '/a/emails' }
+      expect(route).to route_to(controller: 'admin/emails', action: 'index')
+    end
+  end
+
+  describe 'GET #index' do
+    subject do
+      get :index, params: {}
+    end
+
+    before { create :email }
+
+    it 'returns a success response' do
+      subject
+      expect(response).to be_successful
+    end
+
+    context 'when user is not logged in' do
+      let(:logged_user) { nil }
+
+      it 'redirects to login path' do
+        subject
+        expect(response).to redirect_to(new_user_session_path)
+      end
+    end
+
+    context 'when se pide el excel' do
+      subject do
+        get :index, params: {}, format: 'xlsx'
+      end
+
+      it 'returns a success response' do
+        subject
+        expect(response).to be_successful
+      end
+    end
+  end
+
+  describe 'GET #show' do
+    it 'returns a success response' do
+      email = create(:email)
+      email.encoded_eml.attach({ io: StringIO.new(Faker::Lorem.sentence), filename: 'email.eml' })
+      get :show, params: { id: email.to_param }
+      expect(response).to be_successful
+    end
+  end
+
+  describe 'GET #new' do
+    it 'returns a success response' do
+      get :new, params: {}
+      expect(response).to be_successful
+    end
+  end
+
+  describe 'GET #edit' do
+    it 'returns a success response' do
+      email = create(:email)
+      get :edit, params: { id: email.to_param }
+      expect(response).to be_successful
+    end
+  end
+
+  describe 'POST #create' do
+    context 'with valid params' do
+      it 'creates a new Email' do
+        expect do
+          post :create, params: { email: valid_attributes }
+        end.to change(Email, :count).by(1)
+      end
+
+      it 'redirects to the created email' do
+        post :create, params: { email: valid_attributes }
+        expect(response).to redirect_to([:admin, Email.last])
+      end
+    end
+
+    context 'with invalid params' do
+      it 'returns a unprocessable_entity response' do
+        post :create, params: { email: invalid_attributes }
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+
+      it 'renders the new template' do
+        post :create, params: { email: invalid_attributes }
+        expect(response).to render_template(:new)
+      end
+    end
+  end
+
+  describe 'PUT #update' do
+    context 'with valid params' do
+      let(:new_attributes) do
+        attributes_for(:email)
+      end
+
+      it 'updates the requested email' do
+        email = create(:email)
+        put :update, params: { id: email.to_param, email: new_attributes }
+        email.reload
+        expect(email.from_address).to eq new_attributes[:from_address]
+      end
+
+      it 'redirects to the email' do
+        email = create(:email)
+        put :update, params: { id: email.to_param, email: valid_attributes }
+        expect(response).to redirect_to([:admin, email])
+      end
+    end
+
+    context 'with invalid params' do
+      it 'returns a unprocessable_entity response' do
+        email = create(:email)
+        put :update, params: { id: email.to_param, email: invalid_attributes }
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+
+      it 'renders the edit template' do
+        email = create(:email)
+        put :update, params: { id: email.to_param, email: invalid_attributes }
+        expect(response).to render_template(:edit)
+      end
+    end
+  end
+
+  describe 'DELETE #destroy' do
+    subject do
+      request.headers['Accept'] = 'text/vnd.turbo-stream.html,text/html'
+      delete :destroy, params: { id: email.to_param, redirect_to: redirect_url }
+    end
+
+    let!(:email) { create :email }
+    let(:redirect_url) { nil }
+
+    it 'destroys the requested email' do
+      expect { subject }.to change(Email, :count).by(-1)
+    end
+
+    it 'quita el elemento de la lista' do
+      subject
+      expect(response.body).to include('turbo-stream action="remove"')
+    end
+
+    context 'si hay redirect_to' do
+      let(:redirect_url) { admin_emails_url }
+
+      it 'redirects to the emails list' do
+        subject
+        expect(response).to redirect_to(admin_emails_url)
+      end
+    end
+  end
+end

data/pg_engine/spec/controllers/admin/users_controller_spec.rb

@@ -43,10 +43,10 @@ RSpec.describe Admin::UsersController do
     }
   end
 
-  let(:logger_user) { create :user, :admin }
+  let(:logged_user) { create :user, :admin }
 
   before do
-    sign_in logger_user
+    sign_in logged_user
   end
 
   describe 'GET #index' do
@@ -66,7 +66,7 @@ RSpec.describe Admin::UsersController do
 
       it do
         subject
-        expect(assigns(:collection)).to eq [logger_user]
+        expect(assigns(:collection)).to eq [logged_user]
       end
     end
   end

data/pg_engine/spec/factories/emails.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# generado con pg_rails
+
+FactoryBot.define do
+  factory :email do
+    # accepted_at { "2024-05-06 16:41:06" }
+    # delivered_at { "2024-05-06 16:41:06" }
+    # opened_at { "2024-05-06 16:41:06" }
+    from_address { Faker::Internet.email }
+    from_name { Faker::Name.name }
+    reply_to { Faker::Internet.email }
+    to { Faker::Internet.email }
+    subject { Faker::Lorem.sentence }
+    body_input { Faker::Lorem.sentence }
+    # tags { Faker::Lorem.sentence }
+    # associated
+    # message_id { Faker::Lorem.sentence }
+    # mailer { Faker::Lorem.sentence }
+    # status_detail { Faker::Lorem.sentence }
+    # status { rand(1..9999) }
+
+    # trait :associated_existente do
+    #   associated { nil }
+    #   associated_id { Associated.pluck(:id).sample }
+    # end
+  end
+end

data/pg_engine/spec/lib/pg_engine/mailgun/log_sync_spec.rb

@@ -0,0 +1,25 @@
+require 'rails_helper'
+require 'fileutils'
+
+describe PgEngine::Mailgun::LogSync do
+  let(:instancia) { described_class }
+
+  describe '#download',
+           vcr: { cassette_name: 'mailgun/log_sync_download',
+                  match_requests_on: %i[method host] } do
+    subject do
+      instancia.download
+      instancia.sync_redis
+    end
+
+    after do
+      Dir["#{instancia.dir}/*.json"].each { |file| File.delete(file) }
+    end
+
+    let!(:email) { create :email, message_id: '66393f1bc7d4_47a5108ec1628f@notebook.mail' }
+
+    it do
+      expect { subject }.to change { email.logs.to_a.length }.from(0).to(3)
+    end
+  end
+end

data/pg_engine/spec/models/email_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# generado con pg_rails
+
+require 'rails_helper'
+
+RSpec.describe Email do
+  let(:email) { create(:email) }
+
+  it 'se persiste' do
+    expect(email).to be_persisted
+  end
+end

data/pg_layout/app/views/layouts/pg_layout/mailer.html.slim

@@ -0,0 +1,11 @@
+html
+  body style="font-family: sans-serif"
+    = yield
+
+    footer style="margin-top: 2em;"
+      - if @footer_href.present?
+        = link_to @footer_href, rel: 'noreferrer', target: :_blank do
+          - if @footer_image_src.present?
+            = image_tag @footer_image_src, alt: @footer_image_alt
+          - else
+            = @footer_image_alt

data/pg_layout/app/views/layouts/pg_layout/mailer.text.slim

@@ -0,0 +1,4 @@
+= yield
+
+| PgRails
+| https://example.com.ar

data/pg_rails/lib/pg_rails/redis_support.rb

@@ -0,0 +1,6 @@
+RSpec.configure do |config|
+  config.before(:each) do
+    Kredis.redis
+    Kredis.clear_all
+  end
+end

data/pg_rails/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgRails
-  VERSION = '7.0.8-alpha.56'
+  VERSION = '7.0.8-alpha.58'
 end

data/pg_scaffold/lib/generators/pg_rspec/scaffold/templates/controller_spec.rb

@@ -170,7 +170,7 @@ RSpec.describe <%= controller_class_name %>Controller do
 <% else -%>
         post :create, params: { <%= nombre_tabla_completo_singular %>: valid_attributes }
 <% end -%>
-        expect(response).to redirect_to(<%= class_name %>.last.decorate.target_object)
+        expect(response).to redirect_to([:<%= ns_prefix.first %>, <%= class_name %>.last])
       end
     end
 <% if attributes.any? { |at| at.required? } -%>
@@ -218,7 +218,7 @@ RSpec.describe <%= controller_class_name %>Controller do
 <% else -%>
         put :update, params: { id: <%= file_name %>.to_param, <%= nombre_tabla_completo_singular %>: valid_attributes }
 <% end -%>
-        expect(response).to redirect_to(<%= file_name %>.decorate.target_object)
+        expect(response).to redirect_to([:<%= ns_prefix.first %>, <%= file_name %>.decorate.target_object])
       end
     end
 <% if attributes.any? { |at| at.required? } -%>