cnfs-comm 0.0.1.alpha

data/app/models/providers/twilio.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Providers
+  class Twilio < Provider
+    alias_attribute :account_sid, :credential_1
+    alias_attribute :auth_token, :credential_2
+
+    def self.services; %w[sms call] end
+
+    def client
+      @client ||= ::Twilio::REST::Client.new(x_account_sid, x_auth_token) if x_account_sid && x_auth_token
+    end
+
+    def x_account_sid
+      account_sid || (current_tenant.platform_twilio_enabled ? ENV['TWILIO_ACCOUNT_SID'] : nil)
+    end
+
+    def x_auth_token
+      auth_token || (current_tenant.platform_twilio_enabled ? ENV['TWILIO_AUTH_TOKEN'] : nil)
+    end
+
+    def sms(from, to, body)
+      sender = from || provider_from
+      # Rails.logger.warn('No Twilio client configured for tenant.account_id') and return unless client
+      # message.update(from: from)
+      # binding.pry
+      # TODO: toggle sending on and off
+      client.messages.create(from: sender, to: to, body: body)
+      Rails.logger.debug message
+    end
+
+    def call(_message)
+      # to = whatup.From.gsub('whatsapp:', '')
+      client.calls.create(from: from, to: to, url: 'http://demo.twilio.com/docs/voice.xml')
+    end
+  end
+end

data/app/models/template.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class Template < Comm::ApplicationRecord
+  attr_accessor :properties
+
+  after_initialize :initialize_properties
+
+  def initialize_properties
+    self.properties = OpenStruct.new
+  end
+
+  # See: https://www.stuartellis.name/articles/erb/
+  def render(user:, campaign:)
+    properties.user = user
+    properties.campaign = campaign
+
+    final_content = content.dup
+    keys_to_replace = content.scan(/\[[A-z0-9]+\]/)
+    keys_to_replace.each do |key|
+      final_content.gsub!(key, value_for(key))
+    end
+    final_content
+  end
+
+  private
+
+  def key_map
+    { 'salutation' => { property: :user, value: :title },
+      'userFirstName' => { property: :user, value: :first_name },
+      'userLastName' => { property: :user, value: :last_name },
+      'userId' => { property: :user, value: :primary_identifier },
+      'campaignUrl' => { property: :campaign, value: :final_url } }
+  end
+
+  def value_for(key)
+    sanitized_key = key.delete '[]'
+    mapped_key = key_map[sanitized_key]
+    return key if mapped_key.nil? || properties[mapped_key[:property]].nil?
+
+    if sanitized_key != 'campaignUrl'
+      properties[mapped_key[:property]].send(mapped_key[:value])
+    else
+      "#{properties[mapped_key[:property]].send(mapped_key[:value])}?#{campaign_query_params}&#{owner_query_params}"
+    end
+  end
+
+  def campaign_query_params
+    "cid=#{properties.campaign.owner_id}"
+  end
+
+  def owner_query_params
+    "pi=#{properties.user.primary_identifier}"
+  end
+end

data/app/models/tenant.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Tenant < Comm::ApplicationRecord
+  include Ros::TenantConcern
+
+  store_accessor :platform_properties, :platform_twilio_enabled, :platform_aws_enabled
+end

data/app/models/whatsapp.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Whatsapp < Comm::ApplicationRecord
+end

data/app/operations/event_process.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class EventProcess < Ros::ActivityBase
+  step :find_event
+  failed :event_not_found
+  step :create_messages_for_pool
+
+  def find_event(ctx, id:, **)
+    event = ::Event.find(id)
+    # TODO: What if campaign is not set? This returns nil and fails
+    ctx[:event] = event
+    ctx[:template] = event.template
+    ctx[:campaign] = event.campaign
+  rescue ActiveRecord::RecordNotFound
+    false
+  end
+
+  def event_not_found(_ctx, id:, errors:, **)
+    errors.add(:event, "not found for tenant (id: #{id})")
+  end
+
+  def create_messages_for_pool(_ctx, event:, template:, campaign:, **)
+    event.process!
+    # TODO: We need to somehow paginate these users otherwise its going
+    # to burst the server. A pool (event target, can have millions of users)
+    # which will be all returned here (or not if the server goes down)
+    event.users.each do |user|
+      content = template.render(user: user, campaign: campaign)
+      MessageProcessJob.perform_later(
+        params: {
+          to: user.phone_number,
+          provider: event.provider,
+          channel: event.channel,
+          body: content,
+          owner: event
+        }
+      )
+    end
+    event.publish!
+  end
+end

data/app/operations/message_create.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+class MessageCreate < Ros::ActivityBase
+  # step :check_permission
+  # failed :not_permitted, Output(:success) => End(:failure)
+  step :valid_recipient_and_phone_number
+  failed :invalid_recipient_and_phone_number, Output(:success) => End(:failure)
+  step :set_recipient
+  failed :recipient_not_found, Output(:success) => End(:failure)
+  step :match_recipient_and_phone_number
+  failed :mismatched_recipient_and_phone_number, Output(:success) => End(:failure)
+  step :set_final_to
+  step :valid_send_at
+  failed :invalid_send_at, Output(:success) => End(:failure)
+  step :setup_message
+  failed :invalid_message
+  step :save_sms
+  step :send_to_provider
+
+  # NOTE: Ensures that if send_at was sent then it is a valid date/datetime
+  # If send_at is sent and valid, we store it in context, else we jump
+  # to the error track.
+  # If send_at is not sent we will not delay the sms sending and instead send
+  # it immediately
+
+  def check_permission(_ctx, user:, **)
+    MessagePolicy.new(user, Message.new).create?
+  end
+
+  def not_permitted(ctx, **)
+    ctx[:errors].add(:user, 'not permitted to send message')
+  end
+
+  def valid_recipient_and_phone_number(_ctx, params:, **)
+    params[:recipient_id].present? || params[:to].present?
+  end
+
+  def invalid_recipient_and_phone_number(ctx, **)
+    ctx[:errors].add(:recipient, 'is missing')
+  end
+
+  def set_recipient(ctx, params:, **)
+    recipient_id = params[:recipient_id]
+    return true unless recipient_id
+
+    begin
+      ctx[:recipient] = Ros::Cognito::User.find(recipient_id).first
+      ctx[:recipient].errors.blank?
+    rescue JsonApiClient::Errors::NotFound
+      false
+    end
+  end
+
+  def recipient_not_found(ctx, params:, **)
+    ctx[:errors].add(:recipient, "#{params[:recipient_id]} cannot be found")
+  end
+
+  def match_recipient_and_phone_number(ctx, params:, **)
+    recipient_id = params[:recipient_id]
+    to = params[:to]
+    return true unless recipient_id.present? && to.present?
+
+    ctx[:recipient].phone_number == to
+  end
+
+  def mismatched_recipient_and_phone_number(ctx, **)
+    ctx[:errors].add(:recipient, 'mismatch')
+  end
+
+  def set_final_to(ctx, params:, **)
+    params[:to] ||= ctx[:recipient].phone_number
+  end
+
+  def valid_send_at(ctx, **)
+    return true if ctx[:send_at].blank?
+
+    begin
+      parsed_send_at = Time.zone.parse(ctx[:send_at])
+      return false if parsed_send_at.nil?
+
+      ctx[:send_at] = parsed_send_at
+    rescue ArgumentError
+      return false
+    end
+
+    !ctx[:send_at].nil?
+  end
+
+  def invalid_send_at(ctx, **)
+    ctx[:errors].add(:send_at, "is not a valid date format (send_at: #{ctx[:send_at]})")
+  end
+
+  def setup_message(ctx, params:, **)
+    # TODO: If the tenant has a provider set, use the tenant's provider
+    # else default to platform default provider
+    ctx[:model] = Message.new(params)
+    ctx[:model].provider_id = Providers::Aws.first.id
+    ctx[:model].valid?
+  end
+
+  def invalid_message(ctx, model:, **)
+    ctx[:errors] = model.errors
+  end
+
+  def save_sms(_ctx, model:, **)
+    model.save
+  end
+
+  def send_to_provider(ctx, model:, **)
+    if ctx[:send_at].present?
+      MessageSendJob.set(wait_until: ctx[:send_at]).perform_later(id: model.id)
+    else
+      MessageSendJob.perform_later(id: model.id)
+    end
+  end
+end

data/app/operations/message_process.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class MessageProcess < Ros::ActivityBase
+  step :create_message
+  failed :cannot_create_message
+
+  private
+
+  def create_message(ctx, params:, **)
+    ctx[:op_result] = MessageCreate.call(params: params)
+    ctx[:op_result].success?
+  end
+
+  def cannot_create_message(_ctx, op_result:, errors:, **)
+    errors.add(:message, op_result.errors.full_messages.join(', '))
+  end
+end

data/app/operations/message_send.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class MessageSend < Ros::ActivityBase
+  step :retrieve_message
+  failed :message_not_found
+  step :send_message
+  step :update_message_provider_id
+
+  def retrieve_message(ctx, id:, **)
+    ctx[:message] = Message.find_by(id: id)
+  end
+
+  def message_not_found(_ctx, errors:, id:, **)
+    errors.add(:message, "with #{id} not found")
+  end
+
+  def send_message(ctx, message:, **)
+    ctx[:msg_id] = message.provider.send(message.channel, message.from, message.to, message.body)
+  end
+
+  def update_message_provider_id(ctx, message:, **)
+    message.provider_msg_id = ctx[:msg_id]
+    message.save
+  end
+end

data/app/policies/campaign_policy.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class CampaignPolicy < Comm::ApplicationPolicy
+end

data/app/policies/comm/application_policy.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Comm
+  class ApplicationPolicy < ::ApplicationPolicy
+  end
+end

data/app/policies/event_policy.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class EventPolicy < Comm::ApplicationPolicy
+end

data/app/policies/message_policy.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class MessagePolicy < Comm::ApplicationPolicy
+  def create?
+    return false if user.cognito_user_id
+
+    super
+  end
+end

data/app/policies/provider_policy.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ProviderPolicy < Comm::ApplicationPolicy
+end

data/app/policies/template_policy.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class TemplatePolicy < Comm::ApplicationPolicy
+end

data/app/resources/campaign_resource.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class CampaignResource < Comm::ApplicationResource
+  # Serialize the polymorphic :owner association using the specific fields
+  # rather than just :owner since if it is :owner JR will look for the class
+  # which could be in a separate service and therefore fails
+  attributes :name, :description, :owner_type, :owner_id, :base_url
+  has_many :events
+  has_many :templates
+
+  filters :owner_type, :owner_id
+end

data/app/resources/comm/application_resource.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Comm
+  class ApplicationResource < ::ApplicationResource
+    abstract
+  end
+end

data/app/resources/event_resource.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class EventResource < Comm::ApplicationResource
+  attributes :name, :send_at, :provider_id, :campaign_id, :template_id, :channel, :pool_id
+  attributes :target_type, :target_id, :owner_type, :owner_id
+
+  has_one :provider
+  has_one :template
+
+  filters :owner_type, :owner_id
+
+  def fetchable_fields
+    super - %i[pool_id]
+  end
+
+  def pool_id=(pool_id)
+    @model.target_type = 'Ros::Cognito::Pool'
+    @model.target_id = pool_id
+  end
+
+  before_save do
+    # TODO: Make this a valid provider
+    @model.provider_id ||= 1
+  end
+end

data/app/resources/message_resource.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class MessageResource < Comm::ApplicationResource
+  attributes :from, :to, :body, :provider_id, :owner_id, :recipient_id, :owner_type, :channel
+
+  filters :owner_id, :owner_type
+
+  filter :to, apply: lambda { |records, value, _options|
+    records.sent_to(value[0])
+  }
+
+  filter :user_id, apply: lambda { |records, value, _options|
+    user = Ros::Cognito::User.where(id: value[0]).first
+
+    return records.none if user.nil?
+
+    records.sent_to(user.phone_number)
+  }
+
+  def fetchable_fields
+    super + [:provider_msg_id]
+  end
+end

data/app/resources/provider_resource.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ProviderResource < Comm::ApplicationResource
+  attributes :name
+end

data/app/resources/template_resource.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TemplateResource < Comm::ApplicationResource
+  attributes(:name, :description, :content, :status)
+end

data/app/resources/twilio_resource.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+class TwilioResource < ProviderResource; end