possinote 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7366a61c6be2b7e60f16cff7f9052d50ecdc5fb219a26df77d39e296ec1310fe
+  data.tar.gz: ceaa4bf096a171762f26cfa8fdb55a8e231574ef2cc7a69997f604cd022ea9d6
+SHA512:
+  metadata.gz: 4afed04872ab0b3a7cfe33571703cb98807b5faade7bdfa5047f88c41e4bc177ac44a3f75302cbd7d230e3ec82f1cea527590cfa364a1b091f5cdd0276ee4b7d
+  data.tar.gz: 86a358c987ddb7dec4d1484b7262a24e5e9b5afa8688dba0751702d92812cca1e7dd5681c48650c095d34e800c8a91cb7694517a4ec2e900e15fd58fbcb1242d

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PossiNote Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,547 @@
+# Possinote Ruby SDK
+
+Official Ruby SDK for the PossiNote API - Send SMS, emails, and schedule messages with ease.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'possinote'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install possinote
+```
+
+## Quick Start
+
+```ruby
+require 'possinote'
+
+# Initialize the client with your API key
+client = Possinote::Client.new(api_key: 'your_api_key_here')
+
+# Send a single SMS
+response = client.sms.send(
+  to: '+233244123456',
+  message: 'Hello from Possinote!',
+  sender_id: 'YourSenderID'
+)
+
+# Send a single email
+response = client.email.send(
+  recipient: 'user@example.com',
+  subject: 'Welcome to Possinote',
+  content: '<h1>Hello!</h1><p>Welcome to our platform.</p>',
+  sender_name: 'Your Company'
+)
+```
+
+## API Reference
+
+### Authentication
+
+All API requests require authentication using your API key:
+
+```ruby
+client = Possinote::Client.new(api_key: 'your_api_key_here')
+```
+
+### SMS Operations
+
+#### Send Single SMS
+
+```ruby
+response = client.sms.send(
+  to: '+233244123456',
+  message: 'Your message here',
+  sender_id: 'YourSenderID'
+)
+
+# Response
+{
+  "success" => true,
+  "data" => {
+    "message_id" => "msg_123456789",
+    "to" => "+233244123456",
+    "status" => "queued",
+    "cost" => 1.0,
+    "created_at" => "2025-08-11T11:30:00Z"
+  }
+}
+```
+
+#### Send Bulk SMS
+
+```ruby
+response = client.sms.send_bulk(
+  sender_id: 'YourSenderID',
+  messages: [
+    { to: '+233244123456', message: 'Message 1' },
+    { to: '+233244123457', message: 'Message 2' }
+  ]
+)
+
+# Response
+{
+  "success" => true,
+  "data" => {
+    "batch_id" => "batch_123456789",
+    "total_messages" => 2,
+    "successful" => 2,
+    "failed" => 0,
+    "total_cost" => 2.0,
+    "messages" => [
+      { "message_id" => "msg_1", "to" => "+233244123456", "status" => "queued" },
+      { "message_id" => "msg_2", "to" => "+233244123457", "status" => "queued" }
+    ]
+  }
+}
+```
+
+#### Schedule Single SMS
+
+```ruby
+response = client.sms.schedule(
+  recipient: '+233244123456',
+  message: 'Scheduled message',
+  sender_id: 'YourSenderID',
+  scheduled_at: '2025-08-11T12:00:00Z'
+)
+
+# Response
+{
+  "success" => true,
+  "data" => {
+    "id" => "schedule_123456789",
+    "recipient" => "+233244123456",
+    "message" => "Scheduled message",
+    "scheduled_at" => "2025-08-11T12:00:00Z",
+    "status" => "pending",
+    "cost" => "1.0"
+  }
+}
+```
+
+#### Schedule Bulk SMS
+
+```ruby
+response = client.sms.schedule_bulk(
+  sender_id: 'YourSenderID',
+  messages: [
+    { recipient: '+233244123456', message: 'Scheduled message 1' },
+    { recipient: '+233244123457', message: 'Scheduled message 2' }
+  ],
+  scheduled_at: '2025-08-11T12:00:00Z'
+)
+
+# Response
+{
+  "success" => true,
+  "data" => {
+    "batch_id" => "batch_123456789",
+    "scheduled_count" => 2,
+    "total_cost" => 2.0,
+    "scheduled_at" => "2025-08-11T12:00:00Z",
+    "messages" => [
+      { "id" => "schedule_1", "recipient" => "+233244123456", "status" => "pending" },
+      { "id" => "schedule_2", "recipient" => "+233244123457", "status" => "pending" }
+    ]
+  }
+}
+```
+
+### Email Operations
+
+#### Send Single Email
+
+```ruby
+response = client.email.send(
+  recipient: 'user@example.com',
+  subject: 'Welcome Email',
+  content: '<h1>Welcome!</h1><p>Thank you for joining us.</p>',
+  sender_name: 'Your Company'
+)
+
+# Response
+{
+  "success" => true,
+  "message" => "Email queued for delivery",
+  "recipient" => "user@example.com",
+  "message_id" => "email_123456789"
+}
+```
+
+#### Send Bulk Email
+
+```ruby
+response = client.email.send_bulk(
+  subject: 'Newsletter',
+  content: '<h1>Newsletter</h1><p>This is our monthly newsletter.</p>',
+  recipients: ['user1@example.com', 'user2@example.com'],
+  sender_name: 'Your Company'
+)
+
+# Response
+{
+  "success" => true,
+  "message" => "Bulk emails queued for delivery",
+  "queued_count" => 2,
+  "total_count" => 2,
+  "batch_id" => "batch_123456789",
+  "emails" => [
+    { "message_id" => "email_1", "recipient" => "user1@example.com", "status" => "queued" },
+    { "message_id" => "email_2", "recipient" => "user2@example.com", "status" => "queued" }
+  ]
+}
+```
+
+### Scheduling Operations
+
+#### Schedule Single Email
+
+```ruby
+response = client.scheduling.schedule_email(
+  recipient: 'user@example.com',
+  subject: 'Scheduled Email',
+  content: '<h1>Scheduled Content</h1>',
+  scheduled_at: '2025-08-11T12:00:00Z',
+  sender_name: 'Your Company'
+)
+
+# Response
+{
+  "success" => true,
+  "data" => {
+    "id" => "email_schedule_123456789",
+    "recipient" => "user@example.com",
+    "subject" => "Scheduled Email",
+    "scheduled_at" => "2025-08-11T12:00:00Z",
+    "status" => "pending",
+    "cost" => "1.0"
+  }
+}
+```
+
+#### Schedule Bulk Individual Emails
+
+```ruby
+response = client.scheduling.schedule_multiple_emails([
+  {
+    recipient: 'user1@example.com',
+    subject: 'Personalized Email 1',
+    content: '<h1>Hello User 1!</h1>',
+    scheduled_at: '2025-08-11T12:00:00Z',
+    sender_name: 'Your Company'
+  },
+  {
+    recipient: 'user2@example.com',
+    subject: 'Personalized Email 2',
+    content: '<h1>Hello User 2!</h1>',
+    scheduled_at: '2025-08-11T12:00:00Z',
+    sender_name: 'Your Company'
+  }
+])
+
+# Response
+{
+  "success" => true,
+  "data" => {
+    "batch_id" => "batch_123456789",
+    "total_scheduled" => 2,
+    "total_cost" => 2.0,
+    "scheduled_emails" => [
+      { "id" => "email_1", "recipient" => "user1@example.com", "status" => "pending" },
+      { "id" => "email_2", "recipient" => "user2@example.com", "status" => "pending" }
+    ]
+  }
+}
+```
+
+## Framework Integration
+
+### Rails Integration
+
+#### 1. Add to Gemfile
+```ruby
+# Gemfile
+gem 'possinote'
+```
+
+#### 2. Configure in Application
+```ruby
+# config/initializers/possinote.rb
+require 'possinote'
+
+# Initialize the client
+POSSINOTE_CLIENT = Possinote::Client.new(
+  api_key: Rails.application.credentials.possinote[:api_key]
+)
+```
+
+#### 3. Use in Controllers
+```ruby
+# app/controllers/notifications_controller.rb
+class NotificationsController < ApplicationController
+  def send_sms
+    begin
+      response = POSSINOTE_CLIENT.sms.send(
+        to: params[:phone_number],
+        message: params[:message],
+        sender_id: 'YourBrand'
+      )
+      
+      if response['success']
+        render json: { message: 'SMS sent successfully', data: response['data'] }
+      else
+        render json: { error: 'Failed to send SMS' }, status: :unprocessable_entity
+      end
+    rescue Possinote::AuthenticationError => e
+      render json: { error: 'Authentication failed' }, status: :unauthorized
+    rescue Possinote::PaymentRequiredError => e
+      render json: { error: 'Insufficient credits' }, status: :payment_required
+    rescue Possinote::ValidationError => e
+      render json: { error: e.message }, status: :bad_request
+    rescue => e
+      render json: { error: 'An error occurred' }, status: :internal_server_error
+    end
+  end
+
+  def send_bulk_sms
+    begin
+      response = POSSINOTE_CLIENT.sms.send_bulk(
+        sender_id: 'YourBrand',
+        messages: params[:messages] # Array of { to: phone, message: text }
+      )
+      
+      render json: { message: 'Bulk SMS sent', data: response['data'] }
+    rescue => e
+      render json: { error: e.message }, status: :internal_server_error
+    end
+  end
+
+  def send_email
+    begin
+      response = POSSINOTE_CLIENT.email.send(
+        recipient: params[:email],
+        subject: params[:subject],
+        content: params[:content],
+        sender_name: 'Your Company'
+      )
+      
+      render json: { message: 'Email sent successfully', data: response }
+    rescue => e
+      render json: { error: e.message }, status: :internal_server_error
+    end
+  end
+end
+```
+
+#### 4. Use in Services
+```ruby
+# app/services/notification_service.rb
+class NotificationService
+  def initialize
+    @client = POSSINOTE_CLIENT
+  end
+
+  def send_welcome_sms(user)
+    @client.sms.send(
+      to: user.phone_number,
+      message: "Welcome #{user.name}! Your account has been created successfully.",
+      sender_id: 'YourBrand'
+    )
+  end
+
+  def send_password_reset_email(user, reset_token)
+    @client.email.send(
+      recipient: user.email,
+      subject: 'Password Reset Request',
+      content: generate_password_reset_html(user, reset_token),
+      sender_name: 'Your Company'
+    )
+  end
+
+  def send_bulk_newsletter(users, newsletter_content)
+    messages = users.map do |user|
+      {
+        to: user.phone_number,
+        message: "Newsletter: #{newsletter_content[:title]}"
+      }
+    end
+
+    @client.sms.send_bulk(
+      sender_id: 'YourBrand',
+      messages: messages
+    )
+  end
+
+  def schedule_reminder_email(user, appointment)
+    @client.scheduling.schedule_email(
+      recipient: user.email,
+      subject: 'Appointment Reminder',
+      content: generate_appointment_reminder_html(appointment),
+      scheduled_at: appointment.datetime - 1.hour,
+      sender_name: 'Your Company'
+    )
+  end
+
+  private
+
+  def generate_password_reset_html(user, token)
+    <<~HTML
+      <h1>Password Reset Request</h1>
+      <p>Hello #{user.name},</p>
+      <p>You requested a password reset. Click the link below to reset your password:</p>
+      <a href="#{Rails.application.routes.url_helpers.reset_password_url(token: token)}">
+        Reset Password
+      </a>
+      <p>This link will expire in 1 hour.</p>
+    HTML
+  end
+
+  def generate_appointment_reminder_html(appointment)
+    <<~HTML
+      <h1>Appointment Reminder</h1>
+      <p>Hello #{appointment.user.name},</p>
+      <p>This is a reminder for your appointment:</p>
+      <ul>
+        <li><strong>Date:</strong> #{appointment.datetime.strftime('%B %d, %Y')}</li>
+        <li><strong>Time:</strong> #{appointment.datetime.strftime('%I:%M %p')}</li>
+        <li><strong>Location:</strong> #{appointment.location}</li>
+      </ul>
+    HTML
+  end
+end
+```
+
+#### 5. Use in Background Jobs
+```ruby
+# app/jobs/send_notification_job.rb
+class SendNotificationJob < ApplicationJob
+  queue_as :default
+
+  def perform(notification_type, user_id, options = {})
+    user = User.find(user_id)
+    service = NotificationService.new
+
+    case notification_type
+    when 'welcome_sms'
+      service.send_welcome_sms(user)
+    when 'password_reset_email'
+      service.send_password_reset_email(user, options[:reset_token])
+    when 'bulk_newsletter'
+      service.send_bulk_newsletter(options[:users], options[:content])
+    when 'scheduled_reminder'
+      service.schedule_reminder_email(user, options[:appointment])
+    end
+  end
+end
+
+# Usage in controller
+SendNotificationJob.perform_later('welcome_sms', user.id)
+SendNotificationJob.perform_later('password_reset_email', user.id, reset_token: token)
+```
+
+#### 6. Environment Configuration
+```ruby
+# config/credentials.yml.enc
+possinote:
+  api_key: your_api_key_here
+
+# Or use environment variables
+# config/initializers/possinote.rb
+POSSINOTE_CLIENT = Possinote::Client.new(
+  api_key: ENV['POSSINOTE_API_KEY']
+)
+```
+
+## Error Handling
+
+The SDK provides specific exception classes for different error types:
+
+```ruby
+begin
+  response = client.sms.send(to: '+233244123456', message: 'Hello', sender_id: 'SenderID')
+rescue Possinote::AuthenticationError => e
+  puts "Authentication failed: #{e.message}"
+rescue Possinote::PaymentRequiredError => e
+  puts "Payment required: #{e.message}"
+rescue Possinote::RateLimitError => e
+  puts "Rate limit exceeded: #{e.message}"
+rescue Possinote::ValidationError => e
+  puts "Validation error: #{e.message}"
+rescue Possinote::APIError => e
+  puts "API error: #{e.message}"
+end
+```
+
+### Error Types
+
+- `Possinote::AuthenticationError` - Invalid API key (401)
+- `Possinote::PaymentRequiredError` - Insufficient credits (402)
+- `Possinote::RateLimitError` - Rate limit exceeded (429)
+- `Possinote::ValidationError` - Invalid request data (400)
+- `Possinote::APIError` - Other API errors
+
+## Configuration
+
+### Base URL
+
+The SDK uses the production API by default. For testing, you can modify the base URL:
+
+```ruby
+# In lib/possinote/client.rb
+BASE_URI = 'https://notifyapi.possitech.net/api/v1'
+```
+
+### Timeout Settings
+
+HTTP requests use default timeout settings. You can customize them in the client:
+
+```ruby
+# The SDK uses HTTParty defaults
+# You can modify timeout settings in lib/possinote/client.rb
+```
+
+## Requirements
+
+- Ruby >= 2.6.0
+- HTTParty gem
+- JSON gem
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/possitech/possinote-ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/possitech/possinote-ruby/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Support
+
+For support, email support@possitech.net or visit our [documentation](https://docs.possitech.net).
+
+## Changelog
+
+### 1.0.0
+- Initial release
+- SMS sending and scheduling
+- Email sending and scheduling
+- Comprehensive error handling
+- Full API coverage

data/lib/possinote/client.rb

@@ -0,0 +1,63 @@
+module Possinote
+  class Client
+    include HTTParty
+    
+    base_uri 'https://notifyapi.possitech.net/api/v1'
+    format :json
+    
+    attr_reader :api_key
+    
+    def initialize(api_key:)
+      @api_key = api_key
+      self.class.headers 'Authorization' => "Bearer #{api_key}"
+      self.class.headers 'Content-Type' => 'application/json'
+    end
+    
+    def sms
+      @sms ||= SMS.new(self)
+    end
+    
+    def email
+      @email ||= Email.new(self)
+    end
+    
+    def scheduling
+      @scheduling ||= Scheduling.new(self)
+    end
+    
+    def get(path, options = {})
+      handle_response(self.class.get(path, options))
+    end
+    
+    def post(path, options = {})
+      handle_response(self.class.post(path, options))
+    end
+    
+    def put(path, options = {})
+      handle_response(self.class.put(path, options))
+    end
+    
+    def delete(path, options = {})
+      handle_response(self.class.delete(path, options))
+    end
+    
+    private
+    
+    def handle_response(response)
+      case response.code
+      when 200, 201
+        response.parsed_response
+      when 401
+        raise Possinote::AuthenticationError, "Invalid API key"
+      when 402
+        raise Possinote::PaymentRequiredError, response.parsed_response['error'] || "Payment required"
+      when 429
+        raise Possinote::RateLimitError, "Rate limit exceeded"
+      when 400
+        raise Possinote::ValidationError, response.parsed_response['error'] || "Bad request"
+      else
+        raise Possinote::APIError, "API request failed with status #{response.code}"
+      end
+    end
+  end
+end

data/lib/possinote/email.rb

@@ -0,0 +1,47 @@
+module Possinote
+  class Email
+    def initialize(client)
+      @client = client
+    end
+    
+    # Send a single email
+    def send(recipient:, subject:, content:, sender_name: nil)
+      payload = {
+        recipient: recipient,
+        subject: subject,
+        content: content
+      }
+      
+      # Add sender_name only if provided
+      payload[:sender_name] = sender_name if sender_name
+      
+      @client.post('/emails/send', body: payload.to_json)
+    end
+    
+    # Send bulk email
+    def send_bulk(subject:, content:, recipients:, sender_name: nil)
+      payload = {
+        subject: subject,
+        content: content,
+        recipients: recipients
+      }
+      
+      # Add sender_name only if provided
+      payload[:sender_name] = sender_name if sender_name
+      
+      @client.post('/emails/bulk', body: payload.to_json)
+    end
+    
+    # Get email history
+    def history(params = {})
+      query_params = build_query_params(params)
+      @client.get("/emails/history?#{query_params}")
+    end
+    
+    private
+    
+    def build_query_params(params)
+      params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+    end
+  end
+end

data/lib/possinote/errors.rb

@@ -0,0 +1,19 @@
+module Possinote
+  module Errors
+    class BaseError < StandardError
+      attr_reader :code, :response
+      
+      def initialize(message = nil, code = nil, response = nil)
+        super(message)
+        @code = code
+        @response = response
+      end
+    end
+    
+    class AuthenticationError < BaseError; end
+    class PaymentRequiredError < BaseError; end
+    class RateLimitError < BaseError; end
+    class ValidationError < BaseError; end
+    class APIError < BaseError; end
+  end
+end

data/lib/possinote/scheduling.rb

@@ -0,0 +1,63 @@
+module Possinote
+  class Scheduling
+    def initialize(client)
+      @client = client
+    end
+    
+    # Schedule a single email
+    def schedule_email(recipient:, subject:, content:, scheduled_at:, sender_name: nil)
+      payload = {
+        scheduled_email: {
+          recipient: recipient,
+          subject: subject,
+          content: content,
+          scheduled_at: scheduled_at,
+          sender_name: sender_name
+        }
+      }
+      
+      @client.post('/emails/schedule', body: payload.to_json)
+    end
+    
+    # Schedule bulk emails
+    def schedule_bulk_emails(subject:, content:, recipients:, scheduled_at:, sender_name: nil)
+      payload = {
+        bulk_scheduled_email: {
+          subject: subject,
+          content: content,
+          recipients: recipients,
+          scheduled_at: scheduled_at,
+          sender_name: sender_name
+        }
+      }
+      
+      @client.post('/emails/schedule-bulk', body: payload.to_json)
+    end
+    
+    # Schedule multiple individual emails
+    def schedule_multiple_emails(emails:)
+      payload = {
+        emails: emails
+      }
+      
+      @client.post('/emails/schedule-bulk-individual', body: payload.to_json)
+    end
+    
+    # Get scheduled emails
+    def scheduled_emails(params = {})
+      query_params = build_query_params(params)
+      @client.get("/emails/scheduled?#{query_params}")
+    end
+    
+    # Cancel scheduled email
+    def cancel_scheduled_email(id)
+      @client.delete("/emails/scheduled/#{id}")
+    end
+    
+    private
+    
+    def build_query_params(params)
+      params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+    end
+  end
+end

data/lib/possinote/sms.rb

@@ -0,0 +1,82 @@
+module Possinote
+  class SMS
+    def initialize(client)
+      @client = client
+    end
+    
+    # Send a single SMS
+    def send(to:, message:, sender_id:)
+      payload = {
+        sms: {
+          to: to,
+          message: message,
+          sender_id: sender_id
+        }
+      }
+      
+      @client.post('/sms/send', body: payload.to_json)
+    end
+    
+    # Send bulk SMS
+    def send_bulk(sender_id:, messages:)
+      payload = {
+        bulk_sms: {
+          sender_id: sender_id,
+          messages: messages
+        }
+      }
+      
+      @client.post('/sms/bulk', body: payload.to_json)
+    end
+    
+    # Schedule a single SMS
+    def schedule(recipient:, message:, sender_id:, scheduled_at:)
+      payload = {
+        scheduled_sms: {
+          recipient: recipient,
+          message: message,
+          sender_id: sender_id,
+          scheduled_at: scheduled_at
+        }
+      }
+      
+      @client.post('/sms/schedule', body: payload.to_json)
+    end
+    
+    # Schedule bulk SMS
+    def schedule_bulk(sender_id:, messages:, scheduled_at:)
+      payload = {
+        bulk_scheduled_sms: {
+          sender_id: sender_id,
+          messages: messages,
+          scheduled_at: scheduled_at
+        }
+      }
+      
+      @client.post('/sms/schedule-bulk', body: payload.to_json)
+    end
+    
+    # Get SMS history
+    def history(params = {})
+      query_params = build_query_params(params)
+      @client.get("/sms/history?#{query_params}")
+    end
+    
+    # Get scheduled SMS
+    def scheduled(params = {})
+      query_params = build_query_params(params)
+      @client.get("/sms/scheduled?#{query_params}")
+    end
+    
+    # Cancel scheduled SMS
+    def cancel_scheduled(id)
+      @client.delete("/sms/scheduled/#{id}")
+    end
+    
+    private
+    
+    def build_query_params(params)
+      params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+    end
+  end
+end

data/lib/possinote.rb

@@ -0,0 +1,18 @@
+require 'httparty'
+require 'json'
+require_relative 'possinote/client'
+require_relative 'possinote/sms'
+require_relative 'possinote/email'
+require_relative 'possinote/scheduling'
+require_relative 'possinote/errors'
+
+module Possinote
+  VERSION = '1.0.0'
+  
+  class Error < StandardError; end
+  class AuthenticationError < Error; end
+  class PaymentRequiredError < Error; end
+  class RateLimitError < Error; end
+  class ValidationError < Error; end
+  class APIError < Error; end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: possinote
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- PossiNote Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+description: A comprehensive Ruby SDK for sending SMS, emails, and scheduling messages
+  via the PossiNote API
+email:
+- support@possitech.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/possinote.rb
+- lib/possinote/client.rb
+- lib/possinote/email.rb
+- lib/possinote/errors.rb
+- lib/possinote/scheduling.rb
+- lib/possinote/sms.rb
+homepage: https://github.com/charlesagyemang/POSSINOTE-RUBY-GEM
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/charlesagyemang/POSSINOTE-RUBY-GEM
+  changelog_uri: https://github.com/charlesagyemang/POSSINOTE-RUBY-GEM/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/charlesagyemang/POSSINOTE-RUBY-GEM/issues
+  documentation_uri: https://github.com/charlesagyemang/POSSINOTE-RUBY-GEM
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Official Ruby SDK for PossiNote API
+test_files: []