Merge branch 'develop' into feat/email-forwarding

app/services/account/sign_up_email_validation_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Account::SignUpEmailValidationService
+  include CustomExceptions::Account
+  attr_reader :email
+
+  def initialize(email)
+    @email = email
+  end
+
+  def perform
+    address = ValidEmail2::Address.new(email)
+
+    raise InvalidEmail.new({ valid: false, disposable: nil }) unless address.valid?
+
+    raise InvalidEmail.new({ domain_blocked: true }) if domain_blocked?
+
+    raise InvalidEmail.new({ valid: true, disposable: true }) if address.disposable?
+
+    true
+  end
+
+  private
+
+  def domain_blocked?
+    domain = email.split('@').last&.downcase
+    blocked_domains.any? { |blocked_domain| domain.match?(blocked_domain.downcase) }
+  end
+
+  def blocked_domains
+    domains = GlobalConfigService.load('BLOCKED_EMAIL_DOMAINS', '')
+    return [] if domains.blank?
+
+    domains.split("\n").map(&:strip)
+  end
+end

app/services/conversations/filter_service.rb

@@ -28,16 +28,6 @@ class Conversations::FilterService < FilterService
       :taggings, :inbox, { assignee: { avatar_attachment: [:blob] } }, { contact: { avatar_attachment: [:blob] } }, :team, :messages, :contact_inbox
     )
 
-    account_user = @account.account_users.find_by(user_id: @user.id)
-    is_administrator = account_user&.role == 'administrator'
-
-    # Ensure we only include conversations from inboxes the user has access to
-    unless is_administrator
-      inbox_ids = @user.inboxes.where(account_id: @account.id).pluck(:id)
-      conversations = conversations.where(inbox_id: inbox_ids)
-    end
-
-    # Apply permission-based filtering
     Conversations::PermissionFilterService.new(
       conversations,
       @user,

app/services/conversations/permission_filter_service.rb

@@ -8,9 +8,23 @@ class Conversations::PermissionFilterService
   end
 
   def perform
-    # The base implementation simply returns all conversations
-    # Enterprise edition extends this with permission-based filtering
-    conversations
+    return conversations if user_role == 'administrator'
+
+    accessible_conversations
+  end
+
+  private
+
+  def accessible_conversations
+    conversations.where(inbox: user.inboxes.where(account_id: account.id))
+  end
+
+  def account_user
+    AccountUser.find_by(account_id: account.id, user_id: user.id)
+  end
+
+  def user_role
+    account_user&.role
   end
 end
 

app/services/message_templates/template/csat_survey.rb

@@ -12,7 +12,6 @@ class MessageTemplates::Template::CsatSurvey
   private
 
   delegate :contact, :account, :inbox, to: :conversation
-  delegate :csat_config, to: :inbox
 
   def should_send_csat_survey?
     return true unless survey_rules_configured?

app/services/twilio/incoming_message_service.rb

@@ -137,14 +137,19 @@ class Twilio::IncomingMessageService
   end
 
   def download_with_auth(media_url)
-    Down.download(
-      media_url,
-      http_basic_authentication: [twilio_channel.account_sid, twilio_channel.auth_token || twilio_channel.api_key_sid]
-    )
+    auth_credentials = if twilio_channel.api_key_sid.present?
+                         # When using api_key_sid, the auth token should be the api_secret_key
+                         [twilio_channel.api_key_sid, twilio_channel.auth_token]
+                       else
+                         # When using account_sid, the auth token is the account's auth token
+                         [twilio_channel.account_sid, twilio_channel.auth_token]
+                       end
+
+    Down.download(media_url, http_basic_authentication: auth_credentials)
   end
 
   def handle_download_attachment_error(error, media_url)
-    Rails.logger.info "Error downloading attachment from Twilio: #{error.message}: Retrying"
+    Rails.logger.info "Error downloading attachment from Twilio: #{error.message}: Retrying without auth"
     Down.download(media_url)
   rescue StandardError => e
     Rails.logger.info "Error downloading attachment from Twilio: #{e.message}: Skipping"