DEV Community: muzu-85

Integrating Razorpay with Django: A Step-by-Step Guide

muzu-85 — Mon, 17 Jul 2023 05:57:02 +0000

Razorpay is a popular payment gateway solution that enables seamless online transactions. If you're developing a Django project and looking to integrate Razorpay as the payment gateway, this step-by-step guide will walk you through the process. By following these instructions, you'll be able to seamlessly incorporate Razorpay into your Django web application and start accepting payments in no time.

Prerequisites:

Before you begin, make sure you have a Razorpay account. If you haven't signed up yet, head over to https://razorpay.com/ and create an account. Once you have your account, you're ready to proceed with the integration.

Step 1: Install the Razorpay Package

Start by installing the Razorpay Python package in your Django project. Open your terminal or command prompt and run the following command:

pip install razorpay

Step 2: Set Up the Integration Code

In your Django project, create a new directory called 'razorpay_integration' (or any other name of your choice) inside your app directory. This directory will house the integration code. Within the 'razorpay_integration' directory, create a new file called 'razorpay_integration.py'.

Step 3: Initialize the Razorpay Client

In the 'razorpay_integration.py' file, import the necessary modules:

import razorpay
from django.conf import settings

Next, initialize the Razorpay client with your API credentials:

client = razorpay.Client(auth=(settings.RAZORPAY_API_KEY, settings.RAZORPAY_API_SECRET))

Step 4: Create a Payment Function

Define a function to initiate a payment. This function will handle the creation of a Razorpay order and return the order ID. Feel free to customize this function according to your project's requirements. Here's an example:

def initiate_payment(amount, currency='INR'):
   data = {
       'amount': amount * 100,  # Razorpay expects amount in paise (e.g., 100 INR = 10000 paise)
       'currency': currency,
       'payment_capture': '1'  # Auto capture the payment after successful authorization
   }
   response = client.order.create(data=data)
   return response['id']

Step 5: Create a Payment View

Build a Django view that calls the 'initiate_payment' function and renders a payment page with the order ID. Customize the view according to your project's needs. Here's an example:

from django.shortcuts import render

def payment_view(request):
   amount = 100  # Set the amount dynamically or based on your requirements
   order_id = initiate_payment(amount)
   context = {
       'order_id': order_id,
       'amount': amount
   }
   return render(request, 'payment.html', context)

Step 6: Design the Payment Page

Create a template file called 'payment.html' to display the payment page. Utilize Razorpay's JavaScript code to handle the payment form submission. Here's an example:

<script src="https://checkout.razorpay.com/v1/checkout.js"></script>
<form action="{% url 'payment_success' %}" method="POST">
   <input type="hidden" name="order_id" value="{{ order_id }}">
   <script>
       var options = {
           "key": "{{ settings.RAZORPAY_API_KEY }}",
           "amount": "{{ amount }}",
           "currency": "INR",
           "name": "Your Company Name",
           "description": "Payment Description",
           "order_id": "{{ order_id }}",
           "handler": function(response) {
               // Handle the payment success response
               // You can submit the form or redirect to a success page
               document.forms[0].submit();
           },
           "prefill": {
               "name": "John Doe",
               "email": "john@example.com",
               "contact": "9876543210"
           }
       };
       var rzp = new Razorpay(options);
       rzp.open();
   </script>
</form>

Step 7: Handle the Payment Success Callback

Create another Django view to handle the payment success callback. This view will verify the payment status and perform any necessary actions. Here's an example:

def payment_success_view(request):
   order_id = request.POST.get('order_id')
   payment_id = request.POST.get('razorpay_payment_id')
   signature = request.POST.get('razorpay_signature')
   params_dict = {
       'razorpay_order_id': order_id,
       'razorpay_payment_id': payment_id,
       'razorpay_signature': signature
   }
   try:
       client.utility.verify_payment_signature(params_dict)
       # Payment signature verification successful
       # Perform any required actions (e.g., update the order status)
       return render(request, 'payment_success.html')
   except razorpay.errors.SignatureVerificationError as e:
       # Payment signature verification failed
       # Handle the error accordingly
       return render(request, 'payment_failure.html')

Step 8: Update URLs

Modify your Django project's URLs to include the new views. For example:

from django.urls import path
from .views import payment_view, payment_success_view

urlpatterns = [
   path('payment/', payment_view, name='payment'),
   path('payment/success/', payment_success_view, name='payment_success'),
]

Congratulations! You've successfully integrated Razorpay with your Django project. By following this step-by-step guide, you can now accept payments seamlessly within your web application.
Remember to replace 'settings.RAZORPAY_API_KEY' and 'settings.RAZORPAY_API_SECRET' with your actual Razorpay API key and secret in the code. Now you're all set to provide your users with a smooth and secure payment experience.
Happy coding!

Django for newbeeez

muzu-85 — Sat, 18 Mar 2023 16:55:45 +0000

let's explore some django !!!!!!

this is a beginner friendly tutorial

so what is django?

actually,

Django is a powerful web framework that makes building web applications easy and efficient. It is written in Python, and it follows the Model-View-Controller (MVC) architectural pattern. In this tutorial, we will walk through the basics of Django and build a simple web application.

lets dive into it ->

Step 1: Installing Django

Before we start building our application, we need to install Django. We can do this by running the following command in our terminal:

pip install Django

Step 2: Creating a Django Project

Once Django is installed, we can create our first Django project by running the following command in our terminal:

django-admin startproject myproject

This will create a new directory called myproject that contains the basic structure of a Django project.

Step 3: Creating a Django App

Next, we need to create a Django app within our project. We can do this by running the following command:

python manage.py startapp myapp

This will create a new directory called myapp that contains the basic structure of a Django app.

Step 4: Creating a Model

In Django, a model is a representation of a database table. We can define our model in the models.py file within our app directory. Here's an example:

from django.db import models

class MyModel(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    message = models.TextField()

Sure, here's a beginner-friendly tutorial on Django.

Step 5: Creating a View

In Django, a view is a function that handles HTTP requests and returns an HTTP response. We can define our view in the views.py file within our app directory. Here's an example:

from django.shortcuts import render
from .models import MyModel

def index(request):
    if request.method == 'POST':
        name = request.POST['name']
        email = request.POST['email']
        message = request.POST['message']
        MyModel.objects.create(name=name, email=email, message=message)
    return render(request, 'index.html')

This view defines a function called index that handles HTTP requests. If the request is a POST request, it creates a new record in the MyModel table with the data submitted in the form. Finally, it returns a rendered template called index.html.

Step 6: Creating a Template

In Django, a template is a file that defines the structure and layout of a web page. We can define our template in the templates directory within our app directory. Here's an example:

<!DOCTYPE html>
<html>
<head>
    <title>My App</title>
</head>
<body>
    <h1>My App</h1>
    <form method="post">
        {% csrf_token %}
        <label for="name">Name:</label>
        <input type="text" id="name" name="name"><br><br>
        <label for="email">Email:</label>
        <input type="email" id="email" name="email"><br><br>
        <label for="message">Message:</label>
        <textarea id="message" name="message"></textarea><br><br>
        <button type="submit">Submit</button>
    </form>
</body>
</html>

This template defines an HTML form that allows users to submit their name, email, and message.

Step 7: Connecting Everything Together

Finally, we need to connect everything together. We can do this by defining our URLs in the urls.py file within our app directory. Here's an example:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
]

This URL pattern maps the root URL ('') to the index view defined in views.py.

Next, we need to include our app's URLs in the project's URLs. We can do this by adding the following line to the urls.py file within our project directory:

path('', include('myapp.urls')),

This line includes the URLs defined in myapp.urls within the project's URLs.

Step 8: Running the Server

Now that we have everything set up, we can run the server by running the following command in our terminal:

python manage.py runserver

This will start the server on http://127.0.0.1:8000/.

Step 9: Testing the Application

Open your browser and go to http://127.0.0.1:8000/. You should see the form we created in the template. Fill out the form and submit it. If everything is working correctly, you should see a new record in the MyModel table.

Conclusion

In this tutorial, we walked through the basics of Django and built a simple web application. We learned how to create a project, create an app, define a model, define a view, create a template, connect everything together with URLs, and run the server. With this foundation, you can continue to explore Django and build more complex web applications.