Wittyflow Ruby Gem

gem 'wittyflow'

# config/initializers/wittyflow.rb
Wittyflow.configure do |config|
  config.app_id = ENV['WITTYFLOW_APP_ID']
  config.app_secret = ENV['WITTYFLOW_APP_SECRET']
  config.timeout = 30
  config.retries = 3
  config.retry_delay = 1
  config.default_country_code = "233" # Ghana
end

# Using global configuration
client = Wittyflow::Client.new

# Send regular SMS
response = client.send_sms(
  from: "YourApp",
  to: "0241234567",
  message: "Hello from Wittyflow!"
)

# Send flash SMS (appears directly on screen)
response = client.send_flash_sms(
  from: "YourApp", 
  to: "0241234567",
  message: "Urgent: Your verification code is 123456"
)

# Per-instance configuration
client = Wittyflow::Client.new(
  app_id: "your_app_id",
  app_secret: "your_app_secret",
  timeout: 60,
  retries: 5
)

response = client.send_sms(
  from: "YourApp",
  to: "+233241234567",
  message: "Hello World!"
)

# Send to multiple recipients
recipients = ["0241234567", "0241234568", "0241234569"]

results = client.send_bulk_sms(
  from: "YourApp",
  to: recipients,
  message: "Bulk message to all recipients"
)

# Results is an array with response for each recipient
results.each_with_index do |result, index|
  puts "Message to #{recipients[index]}: #{result['status']}"
end

# Check delivery status
status_response = client.message_status("message_id_from_send_response")
puts "Message status: #{status_response['data']['status']}"

# Check account balance
balance_response = client.account_balance
puts "Balance: #{balance_response['data']['balance']} #{balance_response['data']['currency']}"

# app/services/sms_service.rb
class SmsService
  include ActiveModel::Model
  
  attr_accessor :to, :message, :from
  
  validates :to, :message, presence: true
  validates :from, presence: true, length: { maximum: 11 }
  
  def initialize(attributes = {})
    super
    @from ||= Rails.application.credentials.sms_sender_id || "YourApp"
  end
  
  def send_sms
    return false unless valid?
    
    begin
      response = wittyflow_client.send_sms(
        from: from,
        to: to,
        message: message
      )
      
      # Log the response
      Rails.logger.info "SMS sent successfully: #{response}"
      
      # Store in database if needed
      SmsLog.create!(
        recipient: to,
        message: message,
        sender: from,
        external_id: response.dig('data', 'message_id'),
        status: 'sent',
        response: response
      )
      
      true
    rescue Wittyflow::Error => e
      Rails.logger.error "SMS sending failed: #{e.message}"
      errors.add(:base, "Failed to send SMS: #{e.message}")
      false
    end
  end
  
  private
  
  def wittyflow_client
    @wittyflow_client ||= Wittyflow::Client.new
  end
end

# app/controllers/notifications_controller.rb
class NotificationsController < ApplicationController
  before_action :authenticate_user!
  
  def send_sms
    @sms_service = SmsService.new(sms_params)
    
    if @sms_service.send_sms
      flash[:notice] = 'SMS sent successfully!'
      redirect_to notifications_path
    else
      flash[:alert] = @sms_service.errors.full_messages.join(', ')
      render :new
    end
  end
  
  private
  
  def sms_params
    params.require(:sms_service).permit(:to, :message, :from)
  end
end

# app/jobs/send_sms_job.rb
class SendSmsJob < ApplicationJob
  queue_as :default
  
  retry_on Wittyflow::NetworkError, wait: :exponentially_longer, attempts: 3
  retry_on Wittyflow::APIError, wait: 30.seconds, attempts: 2
  
  def perform(recipient, message, sender = nil)
    client = Wittyflow::Client.new
    
    response = client.send_sms(
      from: sender || Rails.application.credentials.sms_sender_id,
      to: recipient,
      message: message
    )
    
    # Update database record if needed
    SmsLog.find_by(recipient: recipient, message: message)
           &.update!(external_id: response.dig('data', 'message_id'))
  end
end

# Usage in controllers or models
SendSmsJob.perform_later(user.phone, "Welcome to our service!", "YourApp")

# app/models/user.rb
class User < ApplicationRecord
  after_create :send_welcome_sms
  
  def send_sms(message, sender = nil)
    return false unless phone.present?
    
    SmsService.new(
      to: phone,
      message: message,
      from: sender
    ).send_sms
  end
  
  def send_verification_code
    code = generate_verification_code
    update(verification_code: code)
    
    send_sms("Your verification code is: #{code}")
  end
  
  private
  
  def send_welcome_sms
    SendSmsJob.perform_later(
      phone,
      "Welcome to #{Rails.application.class.module_parent_name}! Thanks for joining us.",
      "YourApp"
    )
  end
  
  def generate_verification_code
    SecureRandom.random_number(999999).to_s.rjust(6, '0')
  end
end

# db/migrate/xxx_create_sms_logs.rb
class CreateSmsLogs < ActiveRecord::Migration[7.0]
  def change
    create_table :sms_logs do |t|
      t.string :recipient, null: false
      t.text :message, null: false
      t.string :sender
      t.string :external_id
      t.string :status, default: 'pending'
      t.json :response
      t.timestamps
    end
    
    add_index :sms_logs, :recipient
    add_index :sms_logs, :external_id
    add_index :sms_logs, :status
  end
end

# app/models/sms_log.rb
class SmsLog < ApplicationRecord
  validates :recipient, :message, presence: true
  
  enum status: {
    pending: 'pending',
    sent: 'sent',
    delivered: 'delivered',
    failed: 'failed'
  }
  
  scope :recent, -> { order(created_at: :desc) }
  scope :for_recipient, ->(phone) { where(recipient: phone) }
end

# All of these formats work:
client.send_sms(from: "App", to: "0241234567", message: "Hello")      # Local with 0
client.send_sms(from: "App", to: "241234567", message: "Hello")       # Local without 0  
client.send_sms(from: "App", to: "+233241234567", message: "Hello")   # International
client.send_sms(from: "App", to: "233241234567", message: "Hello")    # Country code only

# They all get formatted to: "233241234567"

begin
  client.send_sms(from: "App", to: "0241234567", message: "Hello")
rescue Wittyflow::AuthenticationError => e
  # Invalid app_id or app_secret
  puts "Authentication failed: #{e.message}"
rescue Wittyflow::ValidationError => e
  # Invalid parameters (missing required fields, etc.)
  puts "Validation error: #{e.message}"
rescue Wittyflow::NetworkError => e
  # Network timeout or connection issues
  puts "Network error: #{e.message}"
rescue Wittyflow::APIError => e
  # API-specific errors (rate limiting, server errors)
  puts "API error: #{e.message}"
rescue Wittyflow::Error => e
  # Any other Wittyflow-related error
  puts "Wittyflow error: #{e.message}"
end

# spec/support/wittyflow_helpers.rb
module WittyflowHelpers
  def stub_wittyflow_success(response_data = {})
    allow_any_instance_of(Wittyflow::Client)
      .to receive(:send_sms)
      .and_return({
        'status' => 'success',
        'data' => { 'message_id' => 'msg_123' }.merge(response_data)
      })
  end
  
  def stub_wittyflow_error(error_class = Wittyflow::APIError, message = "API Error")
    allow_any_instance_of(Wittyflow::Client)
      .to receive(:send_sms)
      .and_raise(error_class, message)
  end
end

# In your specs
RSpec.configure do |config|
  config.include WittyflowHelpers
end

# spec/services/sms_service_spec.rb
RSpec.describe SmsService do
  describe '#send_sms' do
    let(:service) { described_class.new(to: '0241234567', message: 'Test') }
    
    context 'when API call succeeds' do
      before { stub_wittyflow_success }
      
      it 'returns true' do
        expect(service.send_sms).to be true
      end
    end
    
    context 'when API call fails' do
      before { stub_wittyflow_error(Wittyflow::NetworkError, 'Network timeout') }
      
      it 'returns false and adds error' do
        expect(service.send_sms).to be false
        expect(service.errors[:base]).to include('Failed to send SMS: Network timeout')
      end
    end
  end
end

# Old way (still works but deprecated)
sms = Wittyflow::Sms.new(app_id, app_secret)
sms.send_sms(sender, phone, message)

# New way
client = Wittyflow::Client.new(app_id: app_id, app_secret: app_secret)
client.send_sms(from: sender, to: phone, message: message)