> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Ruby

> अपने Ruby अनुप्रयोगों में Dodo Payments को एक सुंदर, Ruby-स्वदेशी SDK के साथ एकीकृत करें

Ruby SDK Dodo Payments को आपके Ruby अनुप्रयोगों में एक सरल और सहज तरीके से एकीकृत करने के लिए प्रदान करता है। यह Ruby की परंपराओं और सर्वोत्तम प्रथाओं का पालन करता है, व्यापक त्रुटि प्रबंधन, पृष्ठांकन, और मध्यवर्ती समर्थन प्रदान करता है।

## स्थापना

अपने Gemfile में जेम जोड़ें:

```ruby Gemfile theme={null}
gem "dodopayments", "~> 2.9"
```

<Tip>
  नवीनतम Dodo Payments सुविधाओं तक पहुंचने के लिए हमेशा नवीनतम SDK संस्करण का उपयोग करें। नवीनतम जानकारी के लिए `bundle update dodopayments` को नियमित रूप से चलाएं।
</Tip>

फिर चलाएं:

```bash theme={null}
bundle install
```

<Info>
  SDK Ruby 3.2.0 और उसके बाद के संस्करणों का समर्थन करता है, जिसमें व्यापक प्रकार, त्रुटि हैंडलिंग और पुनः प्रयास तंत्र शामिल हैं।
</Info>

## त्वरित प्रारंभ

क्लाइंट को प्रारंभ करें और एक चेकआउट सत्र बनाएं:

```ruby theme={null}
require "bundler/setup"
require "dodopayments"

dodo_payments = Dodopayments::Client.new(
  bearer_token: ENV["DODO_PAYMENTS_API_KEY"], # This is the default and can be omitted
  environment: "test_mode" # defaults to "live_mode"
)

checkout_session_response = dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 1}]
)

puts(checkout_session_response.session_id)
```

<Warning>
  अपने API कुंजियों को वातावरण चर में सुरक्षित रूप से संग्रहीत करें। उन्हें संस्करण नियंत्रण में कभी कमिट न करें या अपने कोड में उजागर न करें।
</Warning>

## मुख्य विशेषताएँ

<CardGroup cols={2}>
  <Card title="Ruby Conventions" icon="gem">
    Ruby नामकरण शैलियों और आदतपूर्वक पैटर्न का पालन करता है
  </Card>

  <Card title="Elegant Syntax" icon="code">
    साफ़, पठनीय API जो Ruby डेवलपर्स के लिए प्राकृतिक अनुभव देता है
  </Card>

  <Card title="Auto-Pagination" icon="arrows-rotate">
    सूची प्रतिक्रियाओं के लिए अंतर्निर्मित ऑटो-पेजिंग इटरेटर
  </Card>

  <Card title="Type Safety" icon="shield-check">
    बढ़ी हुई टाइप सुरक्षा के लिए वैकल्पिक Sorbet प्रकार
  </Card>
</CardGroup>

## कॉन्फ़िगरेशन

### टाइमआउट कॉन्फ़िगरेशन

अनुरोध टाइमआउट कॉन्फ़िगर करें:

```ruby theme={null}
# Configure default for all requests (default is 60 seconds)
dodo_payments = Dodopayments::Client.new(
  timeout: nil # disable timeout
)

# Or, configure per-request
dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 1}],
  request_options: {timeout: 5}
)
```

### पुनः प्रयास कॉन्फ़िगरेशन

स्वचालित पुनः प्रयास व्यवहार कॉन्फ़िगर करें:

```ruby theme={null}
# Configure default for all requests (default is 2)
dodo_payments = Dodopayments::Client.new(
  max_retries: 0 # disable retries
)

# Or, configure per-request
dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 1}],
  request_options: {max_retries: 5}
)
```

## सामान्य संचालन

### एक चेकआउट सत्र बनाएं

एक चेकआउट सत्र उत्पन्न करें:

```ruby theme={null}
session = dodo_payments.checkout_sessions.create(
  product_cart: [
    {
      product_id: "prod_123",
      quantity: 1
    }
  ],
  return_url: "https://yourdomain.com/return"
)

# Redirect to checkout
redirect_to session.checkout_url
```

### ग्राहकों का प्रबंधन करें

ग्राहक जानकारी बनाएं और पुनः प्राप्त करें:

```ruby theme={null}
# Create a customer
customer = dodo_payments.customers.create(
  email: "customer@example.com",
  name: "John Doe",
  metadata: {
    user_id: "12345"
  }
)

# Retrieve customer
customer = dodo_payments.customers.retrieve("cus_123")
puts "Customer: #{customer.name} (#{customer.email})"
```

### सदस्यताओं को संभालें

आवर्ती सदस्यताएँ बनाएं और प्रबंधित करें:

```ruby theme={null}
# Create a subscription
subscription = dodo_payments.subscriptions.create(
  billing: {
    country: "US",
    city: "San Francisco",
    state: "CA",
    street: "1 Market St",
    zipcode: "94105"
  },
  customer: { customer_id: "cus_123" }, # or { email: "...", name: "..." } for a new customer
  product_id: "pdt_456",
  quantity: 1
)

# Charge an on-demand subscription
# product_price is in the lowest currency denomination (e.g., 2500 = $25.00 USD)
charge = dodo_payments.subscriptions.charge(
  subscription.subscription_id,
  product_price: 2500
)

# Update subscription metadata
updated = dodo_payments.subscriptions.update(
  subscription.subscription_id,
  metadata: { plan_type: "premium" }
)
```

<Info>
  `billing` को कम से कम दो-अक्षर ISO `country` कोड की आवश्यकता होती है। `customer` या तो `{ customer_id: "..." }` का उपयोग करके एक मौजूदा ग्राहक को संलग्न करने के लिए स्वीकार करता है या `{ email: "...", name: "..." }` का उपयोग करके एक नया ग्राहक बनाने के लिए। `product_price` सबसे कम मुद्रा संप्रदाय में है।
</Info>

## पृष्ठांकन

### ऑटो-पृष्ठांकन

सभी पृष्ठों के माध्यम से स्वचालित रूप से इटका करें:

```ruby theme={null}
page = dodo_payments.payments.list

# Fetch single item from page
payment = page.items[0]
puts(payment.brand_id)

# Automatically fetches more pages as needed
page.auto_paging_each do |payment|
  puts(payment.brand_id)
end
```

### मैनुअल पृष्ठांकन

पृष्ठांकन पर अधिक नियंत्रण के लिए:

```ruby theme={null}
page = dodo_payments.payments.list

if page.next_page?
  new_page = page.next_page
  puts(new_page.items[0].brand_id)
end
```

## त्रुटि प्रबंधन

विभिन्न डोडो पेमेंट्स API त्रुटियों को संभालें:

```ruby theme={null}
begin
  checkout_session = dodo_payments.checkout_sessions.create(
product_cart: [{product_id: "product_id", quantity: 1}]
  )
rescue Dodopayments::Errors::APIConnectionError => e
  puts("The server could not be reached")
  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
rescue Dodopayments::Errors::RateLimitError => e
  puts("A 429 status code was received; we should back off a bit.")
rescue Dodopayments::Errors::APIStatusError => e
  puts("Another non-200-range status code was received")
  puts(e.status)
end
```

<Tip>
  आपका अनुप्रयोग उच्च-भारी परिदृश्यों को प्रभावी ढंग से संभाल सके, यह सुनिश्चित करने के लिए दर सीमा त्रुटियों के लिए घातीय बैकऑफ के साथ पुनः प्रयास तर्क को लागू करें।
</Tip>

## Sorbet के साथ प्रकार सुरक्षा

टाइप-सुरक्षित अनुरोध पैरामीटर के लिए Sorbet का उपयोग करें:

```ruby theme={null}
# Type-safe using Sorbet RBI definitions
dodo_payments.checkout_sessions.create(
  product_cart: [
    Dodopayments::ProductItemReq.new(
      product_id: "product_id",
      quantity: 1
    )
  ]
)

# Hashes work, but are not typesafe
dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 1}]
)

# You can also splat a full Params class
params = Dodopayments::CheckoutSessionCreateParams.new(
  product_cart: [
    Dodopayments::ProductItemReq.new(
      product_id: "product_id",
      quantity: 1
    )
  ]
)
dodo_payments.checkout_sessions.create(**params)
```

## उन्नत उपयोग

### डाक्यूमेंटेशनहीन एंडपॉइंट्स

डाक्यूमेंटेशनहीन एंडपॉइंट्स पर अनुरोध करें:

```ruby theme={null}
response = dodo_payments.request(
  method: :post,
  path: '/undocumented/endpoint',
  query: {"dog": "woof"},
  headers: {"useful-header": "interesting-value"},
  body: {"hello": "world"}
)
```

### डाक्यूमेंटेशनहीन पैरामीटर्स

डाक्यूमेंटेशनहीन पैरामीटर्स भेजें:

```ruby theme={null}
checkout_session_response = dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 1}],
  request_options: {
    extra_query: {my_query_parameter: value},
    extra_body: {my_body_parameter: value},
    extra_headers: {"my-header": value}
  }
)

# Access undocumented response properties
puts(checkout_session_response[:my_undocumented_property])
```

## Rails एकीकरण

### इनिशियलाइज़र बनाएं

`config/initializers/dodo_payments.rb` बनाएं:

```ruby theme={null}
require "dodopayments"

DODO_CLIENT = Dodopayments::Client.new(
  bearer_token: Rails.application.credentials.dodo_api_key,
  environment: Rails.env.production? ? "live_mode" : "test_mode"
)
```

### सेवा ऑब्जेक्ट पैटर्न

एक भुगतान सेवा बनाएं:

```ruby theme={null}
# app/services/payment_service.rb
class PaymentService
  def initialize
    @client = DODO_CLIENT
  end

  def create_checkout(items)
    @client.checkout_sessions.create(
      product_cart: items,
      return_url: Rails.application.routes.url_helpers.checkout_return_url
    )
  end

  def process_payment(amount:, currency:, customer_id:)
    @client.payments.create(
      amount: amount,
      currency: currency,
      customer_id: customer_id
    )
  end
end
```

### कंट्रोलर एकीकरण

अपने Rails कंट्रोलर्स में उपयोग करें:

```ruby theme={null}
# app/controllers/checkouts_controller.rb
class CheckoutsController < ApplicationController
  def create
    service = PaymentService.new
    session = service.create_checkout(checkout_params[:items])
    
    redirect_to session.checkout_url, allow_other_host: true
  rescue Dodopayments::Errors::APIError => e
    flash[:error] = "Payment error: #{e.message}"
    redirect_to cart_path
  end

  private

  def checkout_params
    params.require(:checkout).permit(items: [:product_id, :quantity])
  end
end
```

## Sinatra एकीकरण

Sinatra अनुप्रयोगों के साथ उपयोग करें:

```ruby theme={null}
require "sinatra"
require "dodopayments"

configure do
  set :dodo_client, Dodopayments::Client.new(
    bearer_token: ENV["DODO_API_KEY"]
  )
end

post "/create-checkout" do
  content_type :json
  
  begin
    session = settings.dodo_client.checkout_sessions.create(
      product_cart: JSON.parse(request.body.read)["items"],
      return_url: "#{request.base_url}/return"
    )
    
    { checkout_url: session.checkout_url }.to_json
  rescue Dodopayments::Errors::APIError => e
    status 400
    { error: e.message }.to_json
  end
end
```

## संसाधन

<CardGroup cols={2}>
  <Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/dodopayments-ruby">
    स्रोत कोड देखें और योगदान दें
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    पूरी API डाक्यूमेंटेशन
  </Card>

  <Card title="Discord Community" icon="discord" href="https://discord.gg/bYqAp4ayYh">
    मदद प्राप्त करें और डेवलपर्स के साथ कनेक्ट करें
  </Card>

  <Card title="Report Issues" icon="bug" href="https://github.com/dodopayments/dodopayments-ruby/issues">
    बग रिपोर्ट करें या सुविधाओं का अनुरोध करें
  </Card>
</CardGroup>

## समर्थन

Ruby SDK के साथ सहायता की आवश्यकता है?

* **Discord**: वास्तविक समय सहायता के लिए हमारे [समुदाय सर्वर](https://discord.gg/bYqAp4ayYh) से जुड़ें
* **ईमेल**: [support@dodopayments.com](mailto:support@dodopayments.com) पर हमसे संपर्क करें
* **GitHub**: [repository](https://github.com/dodopayments/dodopayments-ruby) पर एक मुद्दा खोलें

## योगदान दे रहे हैं

हम योगदान का स्वागत करते हैं! आरंभ करने के लिए [contributing guidelines](https://github.com/dodopayments/dodopayments-ruby/blob/main/CONTRIBUTING.md) देखें।