pager_tree-integrations 1.0.0

data/app/models/pager_tree/integrations/email/v3.rb

@@ -0,0 +1,150 @@
+module PagerTree::Integrations
+  class Email::V3 < Integration
+    OPTIONS = [
+      {key: :allow_spam, type: :boolean, default: false},
+      {key: :dedup_threads, type: :boolean, default: true}
+    ]
+    store_accessor :options, *OPTIONS.map { |x| x[:key] }.map(&:to_s), prefix: "option"
+
+    validates :option_allow_spam, inclusion: {in: [true, false]}
+    validates :option_dedup_threads, inclusion: {in: [true, false]}
+
+    after_initialize do
+      self.option_allow_spam ||= true
+      self.option_dedup_threads ||= false
+    end
+
+    # SPECIAL: override integration endpoint
+    def endpoint
+      domain = ::PagerTree::Integrations.integration_email_v3_domain
+      inbox = ::PagerTree::Integrations.integration_email_v3_inbox
+      postfix = ""
+      postfix = "_stg" if Rails.env.staging?
+      postfix = "_tst" if Rails.env.test?
+      postfix = "_dev" if Rails.env.development?
+
+      "#{inbox}#{postfix}+#{id}@#{domain}"
+    end
+
+    def adapter_should_block?
+      return false if option_allow_spam == true
+
+      ses_spam_verdict = _get_header("X-SES-Spam-Verdict")&.value
+
+      if ses_spam_verdict.present?
+        return ses_spam_verdict != "PASS"
+      end
+
+      false
+    end
+
+    def adapter_supports_incoming?
+      true
+    end
+
+    def adapter_thirdparty_id
+      _thirdparty_id
+    end
+
+    def adapter_action
+      :create
+    end
+
+    def adapter_process_create
+      Alert.new(
+        title: _title,
+        description: _description,
+        urgency: urgency,
+        thirdparty_id: _thirdparty_id,
+        dedup_keys: _dedup_keys,
+        additional_data: _additional_datums,
+        attachments: _attachments
+      )
+    end
+
+    private
+
+    def _mail
+      @_mail ||= adapter_incoming_request_params.dig("mail")
+    end
+
+    def _inbound_email
+      @_inbound_email ||= adapter_incoming_request_params.dig("inbound_email")
+    end
+
+    def _thirdparty_id
+      _mail.message_id
+    end
+
+    def _dedup_keys
+      keys = [_thirdparty_id]
+      keys.concat(Array(_mail.references)) if option_dedup_threads
+      keys
+    end
+
+    def _title
+      _mail.subject
+    end
+
+    def _description
+      _body
+    end
+
+    def _body
+      return @_body if @_body
+
+      if _mail.multipart? && _mail.html_part
+        document = Nokogiri::HTML(_mail.html_part.body.decoded)
+
+        _attachments_hash.map do |attachment_hash|
+          attachment = attachment_hash[:original]
+          blob = attachment_hash[:blob]
+
+          if attachment.content_id.present?
+            # Remove the beginning and end < >
+            content_id = attachment.content_id[1...-1]
+            element = document.at_css "img[src='cid:#{content_id}']"
+
+            element&.replace "<action-text-attachment sgid=\"#{blob.attachable_sgid}\" content-type=\"#{attachment.content_type}\" filename=\"#{attachment.filename}\"></action-text-attachment>"
+          end
+        end
+
+        @_body = ::Sanitize.document(document, Sanitize::Config::RELAXED)
+      elsif _mail.multipart? && _mail.text_part
+        @_body = _mail.text_part.body.decoded
+      else
+        @_body = _mail.decoded
+      end
+
+      @_body
+    end
+
+    def _attachments_hash
+      @_attachments_hash ||= _mail.attachments.map do |attachment|
+        blob = ActiveStorage::Blob.create_and_upload!(
+          io: StringIO.new(attachment.body.to_s),
+          filename: attachment.filename,
+          content_type: attachment.content_type
+        )
+        {original: attachment, blob: blob}
+      end
+    end
+
+    def _attachments
+      _attachments_hash.map { |attachment_hash| attachment_hash[:blob] }
+    end
+
+    # TODO: Implement any additional data that should be shown in the alert with high priority (be picky as to 'very important' information)
+    def _additional_datums
+      [
+        AdditionalDatum.new(format: "email", label: "From", value: _mail.from),
+        AdditionalDatum.new(format: "email", label: "To", value: _mail.to),
+        AdditionalDatum.new(format: "email", label: "CCs", value: _mail.cc)
+      ]
+    end
+
+    def _get_header(name)
+      _mail.header_fields.find { |x| x.name == name }
+    end
+  end
+end

data/app/models/pager_tree/integrations/integration.rb

@@ -0,0 +1,130 @@
+module PagerTree::Integrations
+  class Integration < PagerTree::Integrations.integration_parent_class.constantize
+    serialize :options, JSON
+    encrypts :options
+
+    GENERIC_OPTIONS = [
+      {key: :title_template, type: :string, default: nil},
+      {key: :title_template_enabled, type: :boolean, default: false},
+      {key: :description_template, type: :string, default: nil},
+      {key: :description_template_enabled, type: :string, default: false}
+    ]
+    store_accessor :options, *GENERIC_OPTIONS.map { |x| x[:key] }.map(&:to_s), prefix: "option"
+
+    before_validation :cast_types
+
+    attribute :option_title_template_enabled, :boolean, default: false
+    attribute :option_description_template_enabled, :boolean, default: false
+    attribute :option_title_template, :string, default: nil
+    attribute :option_description_template, :string, default: nil
+
+    # careful controller is not always guaranteed
+    attribute :adapter_controller
+    # for handling incoming requests
+    attribute :adapter_incoming_request_params
+    # for getting the most data, but not always guaranteed
+    attribute :adapter_incoming_deferred_request
+    # alert if found (by thirdparty id)
+    attribute :adapter_alert
+    # the outgoing event
+    attribute :adapter_outgoing_event
+
+    # START basic incoming functions
+    def adapter_supports_incoming?
+      false
+    end
+
+    # A unique identifier for this integration/alert
+    def adapter_thirdparty_id
+      ULID.generate
+    end
+
+    def adapter_incoming_can_defer?
+      true
+    end
+
+    # Returns :create, :acknowledge, :resolve, or :other
+    def adapter_action
+      :other
+    end
+
+    def adapter_process_create
+    end
+    # END basic incoming functions
+
+    # START basic outgoing functions
+    def adapter_supports_outgoing?
+      false
+    end
+
+    def adapter_outgoing_interest?(event_name)
+      false
+    end
+
+    def adapter_process_outgoing
+    end
+    # END basic outgoing functions
+
+    # START basic show functions
+    def adapter_show_alerts?
+      adapter_supports_incoming?
+    end
+
+    def adapter_show_logs?
+      true
+    end
+
+    def adapter_show_outgoing_webhook_delivery?
+      false
+    end
+    # END basic show functions
+
+    def adapter_response_rate_limit
+      adapter_controller&.head(:not_found)
+    end
+
+    def adapter_response_disabled
+      adapter_controller&.head(:method_not_allowed)
+    end
+
+    def adapter_response_inactive_subscription
+      adapter_controller&.head(:payment_required)
+    end
+
+    def adapter_response_upgrade
+      adapter_controller&.head(:payment_required)
+    end
+
+    def adapter_response_maintenance_mode
+      adapter_controller&.head(:ok)
+    end
+
+    def adapter_response_blocked
+      adapter_controller&.head(:bad_request)
+    end
+
+    def adapter_response_deferred
+      adapter_controller&.head(:ok)
+    end
+
+    def adapter_response_incoming
+      adapter_controller&.head(:ok)
+    end
+
+    def cast_types
+      (self.class.const_get(:GENERIC_OPTIONS) + self.class.const_get(:OPTIONS)).each do |option|
+        key = option[:key]
+        value = send("option_#{key}")
+        type = option[:type]
+
+        value = ActiveModel::Type::Boolean.new.cast(value) if type == :boolean
+        value = ActiveModel::Type::String.new.cast(value) if type == :string
+        value = ActiveModel::Type::Integer.new.cast(value) if type == :integer
+
+        value = option[:default] if value.nil? && option.has_key?(:default)
+
+        send("option_#{key}=", value)
+      end
+    end
+  end
+end

data/app/models/pager_tree/integrations/live_call_routing/twilio/v3.rb

@@ -0,0 +1,332 @@
+module PagerTree::Integrations
+  class LiveCallRouting::Twilio::V3 < Integration
+    OPTIONS = [
+      {key: :account_sid, type: :string, default: nil},
+      {key: :api_key, type: :string, default: nil},
+      {key: :api_secret, type: :string, default: nil},
+      {key: :force_input, type: :boolean, default: false},
+      {key: :record, type: :boolean, default: false},
+      {key: :record_email, type: :string, default: ""}
+    ]
+    store_accessor :options, *OPTIONS.map { |x| x[:key] }.map(&:to_s), prefix: "option"
+
+    has_one_attached :option_connect_now_media
+    has_one_attached :option_music_media
+    has_one_attached :option_no_answer_media
+    has_one_attached :option_no_answer_thank_you_media
+    has_one_attached :option_please_wait_media
+    has_one_attached :option_welcome_media
+
+    validates :option_account_sid, presence: true
+    validates :option_api_key, presence: true
+    validates :option_api_secret, presence: true
+    validates :option_force_input, inclusion: {in: [true, false]}
+    validates :option_record, inclusion: {in: [true, false]}
+    validate :validate_record_emails
+
+    after_initialize do
+      self.option_account_sid ||= nil
+      self.option_api_key ||= nil
+      self.option_api_secret ||= nil
+      self.option_force_input ||= false
+      self.option_record ||= false
+      self.option_record_email ||= ""
+    end
+
+    SPEAK_OPTIONS = {
+      language: "en",
+      voice: "man"
+    }
+
+    TWILIO_LIVECALL_CONNECT_NOW = "https://app.pagertree.com/assets/sounds/you-are-now-being-connected.mp3"
+    TWILIO_LIVECALL_MUSIC = "http://com.twilio.sounds.music.s3.amazonaws.com/oldDog_-_endless_goodbye_%28instr.%29.mp3"
+    TWILIO_LIVECALL_PLEASE_WAIT = "https://app.pagertree.com/assets/sounds/please-wait.mp3"
+
+    def option_connect_now_media_url
+      option_connect_now_media&.url || TWILIO_LIVECALL_CONNECT_NOW
+    end
+
+    def option_music_media_url
+      option_music_media&.url || TWILIO_LIVECALL_MUSIC
+    end
+
+    def option_please_wait_media_url
+      option_please_wait_media&.url || TWILIO_LIVECALL_PLEASE_WAIT
+    end
+
+    def option_record_emails=(x)
+      self.option_record_email = Array(x).join(",")
+    end
+
+    def option_record_emails
+      self.option_record_email.split(",")
+    end
+
+    def option_record_emails_list=(x)
+      # what comes in as json, via tagify
+      uniq_array = []
+      begin
+        uniq_array = JSON.parse(x).map { |y| y["value"] }.uniq
+      rescue JSON::ParserError => exception
+        Rails.logger.debug(exception)
+      end
+
+      self.option_record_emails = uniq_array
+    end
+
+    def option_record_emails_list
+      option_record_emails
+    end
+
+    def validate_record_emails
+      errors.add(:record_emails, "must be a valid email") if option_record_emails.any? { |x| !x.match(URI::MailTo::EMAIL_REGEXP) }
+    end
+
+    def adapter_supports_incoming?
+      true
+    end
+
+    def adapter_supports_outgoing?
+      true
+    end
+
+    def adapter_incoming_can_defer?
+      false
+    end
+
+    def adapter_action
+      :create
+    end
+
+    def adapter_thirdparty_id
+      _thirdparty_id
+    end
+
+    def adapter_process_create
+      Alert.new(
+        title: _title,
+        urgency: urgency,
+
+        thirdparty_id: _thirdparty_id,
+        dedup_keys: [_thirdparty_id],
+        additional_data: _additional_datums
+      )
+    end
+
+    def adapter_response_incoming
+      if _teams_size == 0
+        _twiml.say(message: "This integration is not configured to route to any teams. Goodbye", **SPEAK_OPTIONS)
+        _twiml.hangup
+        return adapter_controller&.render(xml: _twiml.to_xml)
+      end
+
+      if !adapter_alert.meta["live_call_welcome"] && option_welcome_media.present?
+        adapter_alert.logs.create!(message: "Play welcome media to caller.")
+        _twiml.play(url: option_welcome_media.url)
+        adapter_alert.meta["live_call_welcome"] = true
+        adapter_alert.save!
+      end
+
+      if selected_team
+        adapter_alert.logs.create!(message: "Caller selected team '#{selected_team.name}'. Playing please wait media.")
+        _twiml.play(url: option_please_wait_media&.url || TWILIO_LIVECALL_PLEASE_WAIT)
+        friendly_name = adapter_alert.id
+
+        # create the queue and save it off
+        queue = _client.queues.create(friendly_name: friendly_name)
+        adapter_alert.meta["live_call_queue_sid"] = queue.sid
+        adapter_alert.save!
+
+        _twiml.enqueue(
+          name: friendly_name,
+          action: PagerTree::Integrations::Engine.routes.url_helpers.queue_status_live_call_routing_twilio_v3_path(id, thirdparty_id: _thirdparty_id),
+          method: "POST",
+          wait_url: PagerTree::Integrations::Engine.routes.url_helpers.music_live_call_routing_twilio_v3_path(id, thirdparty_id: _thirdparty_id),
+          wait_url_method: "GET"
+        )
+      else
+        adapter_alert.meta["live_call_repeat_count"] ||= 0
+        adapter_alert.meta["live_call_repeat_count"] += 1
+        adapter_alert.save!
+
+        if adapter_alert.meta["live_call_repeat_count"] <= 3
+          adapter_alert.logs.create!(message: "Caller has not selected a team. Playing team options.")
+          _twiml.gather numDigits: _teams_size.to_s.size, timeout: 30 do |g|
+            3.times do
+              g.say(message: _teams_message, **SPEAK_OPTIONS)
+              g.pause(length: 1)
+            end
+          end
+        else
+          adapter_alert.logs.create!(message: "Caller input bad input (too many times). Hangup.")
+          _twiml.say(message: "Too much invalid input. Goodbye.", **SPEAK_OPTIONS)
+          _twiml.hangup
+        end
+      end
+
+      adapter_controller&.render(xml: _twiml.to_xml)
+    end
+
+    def adapter_response_disabled
+      _twiml.say(message: "This integration is currently disabled. Goodbye!", **SPEAK_OPTIONS)
+      _twiml.hangup
+
+      adapter_controller&.render(xml: _twiml.to_xml)
+    end
+
+    def adapter_response_upgrade
+      _twiml.say(message: "This account must be upgraded to use live call routing. Goodbye!", **SPEAK_OPTIONS)
+      _twiml.hangup
+
+      adapter_controller&.render(xml: _twiml.to_xml)
+    end
+
+    def adapter_response_maintenance_mode
+      _twiml.say(message: "This integration is currently in maintenance mode. Goodbye!", **SPEAK_OPTIONS)
+      _twiml.hangup
+
+      adapter_controller&.render(xml: _twiml.to_xml)
+    end
+
+    def adapter_response_music
+      _twiml.play(url: option_music_media_url, loop: 0)
+      adapter_controller&.render(xml: _twiml.to_xml)
+    end
+
+    def response_dropped
+      recording_url = adapter_incoming_request_params.dig("RecordingUrl")
+
+      if recording_url
+        if option_no_answer_thank_you_media.present?
+          _twiml.play(url: option_no_answer_thank_you_media.url)
+        else
+          _twiml.say(message: "Thank you for your message. Goodbye.")
+        end
+        _twiml.hangup
+
+        adapter_alert.additional_data.push(AdditionalDatum.new(format: "link", label: "Voicemail", value: recording_url).to_h)
+        adapter_alert.save!
+
+        adapter_alert.logs.create!(message: "Caller left a <a href='#{recording_url}' target='_blank'>voicemail</a>.")
+
+        adapter_record_emails.each do |email|
+          TwilioLiveCallRouting::V3Mailer.with(email: email, alert: alert).call_recording.deliver_later
+        end
+      elsif record
+        _twiml.play(url: option_no_answer_media_url)
+        _twiml.record(max_length: 60)
+      else
+        _twiml.say(message: "No one is available to answer this call. Goodbye.")
+        _twiml.hangup
+      end
+
+      controller.render(xml: _twiml.to_xml)
+    end
+
+    def adapter_process_queue_status_deferred
+      queue_result = adapter_incoming_request_params.dig("QueueResult")
+      adapter_source_log&.sublog("Processing queus status #{queue_result}")
+
+      if queue_result == "hangup"
+        self.adapter_alert = alerts.find_by(thirdparty_id: _thirdparty_id)
+        queue_destroy
+      end
+
+      adapter_source_log&.save!
+    end
+
+    def perform_outgoing(**params)
+      event = params[:event]
+      if event == "alert.acknowledged"
+        on_acknowledge
+      elsif event == "alert.dropped"
+        on_drop
+      end
+    end
+
+    private
+
+    def _thirdparty_id
+      adapter_incoming_request_params.dig("CallSid")
+    end
+
+    def _title
+      "Incoming call from #{adapter_incoming_request_params.dig("From")}"
+    end
+
+    def _additional_datums
+      [
+        AdditionalDatum.new(format: "phone", label: "Caller Phone", value: adapter_incoming_request_params.dig("From")),
+        AdditionalDatum.new(format: "text", label: "Caller City", value: adapter_incoming_request_params.dig("CallerCity")),
+        AdditionalDatum.new(format: "text", label: "Caller State", value: adapter_incoming_request_params.dig("CallerState")),
+        AdditionalDatum.new(format: "text", label: "Caller Zipcode", value: adapter_incoming_request_params.dig("CallerZipcode")),
+        AdditionalDatum.new(format: "text", label: "Caller Country", value: adapter_incoming_request_params.dig("CallerCountry"))
+      ]
+    end
+
+    def _client
+      @_client ||= ::Twilio::REST::Client.new(self.option_api_key, self.option_api_secret, self.option_account_sid)
+    end
+
+    def _call
+      @_call ||= _client.calls(call_sid).fetch
+    end
+
+    def _twiml
+      @_twiml ||= ::Twilio::TwiML::VoiceResponse.new
+    end
+
+    def _teams_size
+      @_teams_size ||= teams.size
+    end
+
+    def _teams_sorted
+      @_teams_sorted ||= teams.order(name: :desc)
+    end
+
+    def _teams_message
+      "Make a selection followed by the pound sign. " + _teams_sorted.each_with_index.map { |team, index| "#{index + 1} for #{team.name}." }.join(" ")
+    end
+
+    def _digits
+      @_digits ||= adapter_incoming_request_params.dig("Digits")&.to_i
+    end
+
+    def selected_team
+      return nil if _teams_size == 0
+      return _teams_sorted.first if _teams_size == 1 && option_force_input == false
+      return _teams_sorted[_digits - 1] if _digits.present?
+      nil
+    end
+
+    def on_acknowledge
+      # log that we are going to transfer
+      adapter_alert.logs.create!(message: "Attempting to transfer the call...")
+
+      # try to transfer the caller
+      number = "+19402733696"
+      _twiml.play(url: option_connect_now_media_url)
+      _twiml.pause(length: 1)
+      _twiml.dial(number: number, caller_id: _call.to, answer_on_bridge: true)
+      _call.update(twiml: _twiml.to_xml)
+
+      # log if we successfully transfered or failed
+      adapter_alert.logs.create!(message: "Tranferring the call succeeded.")
+    end
+
+    def on_drop
+      _call.update(url: PagerTree::Integrations::Engine.routes.url_helpers.dropped_twilio_live_call_routing_v3_url(id, thirdparty_id: thirdparty_id))
+    end
+
+    def queue_destroy
+      if (queue_sid = adapter_alert&.meta&.fetch("live_call_queue_sid", nil))
+        begin
+          _client.queues(queue_sid).delete
+          adapter_source_log&.sublog("Successfully destroyed queue")
+        rescue => exception
+          adapter_source_log&.sublog("Failed to destroy queue - #{exception.message}")
+        end
+      end
+    end
+  end
+end

data/app/models/pager_tree/integrations/outgoing_event.rb

@@ -0,0 +1,25 @@
+module PagerTree::Integrations
+  class OutgoingEvent
+    include ActiveModel::Model
+    include ActiveModel::API
+    extend ActiveModel::Callbacks
+
+    attr_accessor :event_name
+    attr_accessor :item
+    attr_accessor :changes
+
+    define_model_callbacks :initialize
+
+    def initialize(params = {})
+      run_callbacks :initialize do
+        super(params)
+      end
+    end
+
+    after_initialize do
+      self.event_name ||= nil
+      self.item ||= nil
+      self.changes ||= nil
+    end
+  end
+end

data/app/models/pager_tree/integrations/outgoing_webhook/v3.rb

@@ -0,0 +1,75 @@
+module PagerTree::Integrations
+  class OutgoingWebhook::V3 < Integration
+    OPTIONS = [
+      {key: :webhook_url, type: :string, default: nil},
+      {key: :username, type: :string, default: nil},
+      {key: :password, type: :string, default: nil},
+      {key: :alert_created, type: :boolean, default: false},
+      {key: :alert_open, type: :boolean, default: false},
+      {key: :alert_acknowledged, type: :boolean, default: false},
+      {key: :alert_rejected, type: :boolean, default: false},
+      {key: :alert_timeout, type: :boolean, default: false},
+      {key: :alert_resolved, type: :boolean, default: false},
+      {key: :alert_dropped, type: :boolean, default: false},
+      {key: :alert_handoff, type: :boolean, default: false},
+      {key: :template, type: :string, default: nil},
+      {key: :send_linked, type: :boolean, default: false}
+    ]
+    store_accessor :options, *OPTIONS.map { |x| x[:key] }.map(&:to_s), prefix: "option"
+
+    validates :option_webhook_url, presence: true, url: {no_local: true}
+    validates :option_alert_created, inclusion: {in: [true, false]}
+    validates :option_alert_open, inclusion: {in: [true, false]}
+    validates :option_alert_acknowledged, inclusion: {in: [true, false]}
+    validates :option_alert_rejected, inclusion: {in: [true, false]}
+    validates :option_alert_timeout, inclusion: {in: [true, false]}
+    validates :option_alert_resolved, inclusion: {in: [true, false]}
+    validates :option_alert_dropped, inclusion: {in: [true, false]}
+    validates :option_alert_handoff, inclusion: {in: [true, false]}
+    validates :option_send_linked, inclusion: {in: [true, false]}
+
+    after_initialize do
+      self.option_alert_created ||= false
+      self.option_alert_open ||= false
+      self.option_alert_acknowledged ||= false
+      self.option_alert_rejected ||= false
+      self.option_alert_timeout ||= false
+      self.option_alert_resolved ||= false
+      self.option_alert_dropped ||= false
+      self.option_alert_handoff ||= false
+      self.option_send_linked ||= false
+      self.option_template ||= ""
+    end
+
+    def adapter_supports_outgoing?
+      true
+    end
+
+    def adapter_show_outgoing_webhook_delivery?
+      true
+    end
+
+    def adapter_outgoing_interest?(event_name)
+      try("option_#{event_name}") || false
+    end
+
+    def adapter_process_outgoing
+      body = {
+        data: adapter_outgoing_event.item,
+        type: adapter_outgoing_event.event_name
+      }
+
+      # create the delivery, save it, and send it later
+      outgoing_webhook_delivery = OutgoingWebhookDelivery.factory(
+        resource: self,
+        url: option_webhook_url,
+        auth: {username: option_username, password: option_password},
+        body: body
+      )
+      outgoing_webhook_delivery.save!
+      outgoing_webhook_delivery.deliver_later
+
+      outgoing_webhook_delivery
+    end
+  end
+end