DEV Community: Karanjot Singh

Connect Microsoft Outlook Calendar to Django Application

Karanjot Singh — Fri, 30 Aug 2024 22:04:16 +0000

A Step-by-Step Guide to Seamlessly Microsoft Outlook Calendar with Your Django Application for Enhanced Scheduling and Event Management.

Integrating Outlook Calendar with your Django application allows you to manage scheduling, appointments, and event synchronization seamlessly within your app. This article provides a comprehensive guide to connecting Outlook Calendar using Microsoft's Graph API, including setting up API credentials, handling OAuth2 authentication, and making API requests.

Prerequisites

Before starting, ensure you have the following:

Django Application: A functioning Django application.
Microsoft Azure Account: Access to the Azure portal.
Registered Application in Azure: You need to register your application in Microsoft Entra ID, (earlier Azure Active Directory or Azure AD) to obtain the necessary credentials.

Step 1: Register an Application in Azure AD

Sign in to the Azure Portal:

Go to the Azure Portal and log in with your Microsoft account.
Create a New App Registration:
- Navigate to Microsoft Entra ID > App registrations. (You can search Microsoft Entra ID in the search bar at the top)
- Click on New registration.
- Fill in the details such as name, supported account types, and redirect URI (e.g., http://localhost:8000/callback/ for local development).
- Click Register.
Get Client ID and Tenant ID:

After registration, note down the Application (client) ID and Directory (tenant) ID. If you want to have users outside of your organization then the tenant id would be the word common instead of the application tenant id.
Create a Client Secret:
- Navigate to Certificates & secrets in your registered app.
- Click on New client secret.
- Add a description and select the expiry duration.
- Click Add and save the generated secret value (not secret id) securely. You’ll need this in your Django application.

Step 2: Configure API Permissions

Add Calendar Permissions:
- Go to API permissions and click on Add a permission.
- Select Microsoft Graph.
- Choose Delegated permissions.
- Search for and add the following permissions:
  - Calendars.ReadWrite (Full access to calendars, allowing read and write operations).
  - Calendars.Read (Read-only access to calendars).
- Click Add permissions.
Grant Admin Consent:
- If you have admin rights, click Grant admin consent to enable the application to use these permissions without user prompts.

Step 3: Install Required Python Packages

Install the necessary Python packages to handle Microsoft authentication and API requests:

pip install msal requests

Step 4: Configure Django Settings

In your settings.py, add the following configurations:

import os

# Microsoft Graph API settings
MS_CLIENT_ID = 'your-client-id'
MS_CLIENT_SECRET = 'your-client-secret'
MS_TENANT_ID = 'your-tenant-id'
MS_REDIRECT_URI = 'http://localhost:8000/callback/'  # or your production URL
MS_SCOPES = ['Calendars.ReadWrite']

Step 5: Implement OAuth2 Flow

Create a view to initiate and handle the OAuth2 flow:

from msal import ConfidentialClientApplication
from django.shortcuts import redirect
from django.conf import settings
from django.http import HttpResponse, JsonResponse

def outlook_calendar_init(request):
    client_app = ConfidentialClientApplication(
        client_id=settings.MS_CLIENT_ID,
        client_credential=settings.MS_CLIENT_SECRET,
        authority=f'https://login.microsoftonline.com/{settings.MS_TENANT_ID}'
    )

    authorization_url = client_app.get_authorization_request_url(
        scopes=settings.MS_SCOPES,
        redirect_uri=settings.MS_REDIRECT_URI
    )

    return redirect(authorization_url)

def outlook_calendar_callback(request):
    code = request.GET.get('code')

    if not code:
        return HttpResponse('Authorization code not found in callback.', status=400)

    client_app = ConfidentialClientApplication(
        client_id=settings.MS_CLIENT_ID,
        client_credential=settings.MS_CLIENT_SECRET,
        authority=f'https://login.microsoftonline.com/{settings.MS_TENANT_ID}'
    )

    try:
        token_response = client_app.acquire_token_by_authorization_code(
            code=code,
            scopes=settings.MS_SCOPES,
            redirect_uri=settings.MS_REDIRECT_URI
        )

        if 'access_token' in token_response:
            request.session['ms_access_token'] = token_response['access_token']
            return HttpResponse('Outlook Calendar integration complete. You can now use Outlook Calendar with your Django app.')
        else:
            error_msg = token_response.get('error_description', 'Failed to authenticate.')
            return HttpResponse(f'Authentication failed: {error_msg}', status=401)

    except Exception as e:
        return HttpResponse(f'An error occurred: {str(e)}', status=500)

Step 6: Handle Outlook Calendar API Requests

With the OAuth2 flow completed, you can now make authenticated requests to the Microsoft Graph API to interact with the Outlook Calendar. Here's an example to list the user's calendar events:

import requests

def list_events(request):
    access_token = request.session.get('ms_access_token')

    if not access_token:
        return HttpResponse('User not authenticated.', status=401)

    headers = {
        'Authorization': f'Bearer {access_token}'
    }
    events_url = 'https://graph.microsoft.com/v1.0/me/events'
    response = requests.get(events_url, headers=headers)

    if response.status_code == 200:
        events = response.json().get('value', [])
        return JsonResponse(events, safe=False)
    else:
        return HttpResponse('Failed to fetch events.', status=response.status_code)

Step 7: Update URLs

Add the URLs for the views in your urls.py:

from django.urls import path
from . import views

urlpatterns = [
    path('outlook-calendar/init/', views.outlook_calendar_init, name='outlook_calendar_init'),
    path('callback/', views.outlook_calendar_callback, name='outlook_calendar_callback'),
    path('outlook-calendar/events/', views.list_events, name='list_events'),
]

Step 8: Run and Test

Start Your Django Server:

Run your Django development server using python manage.py runserver.
Authenticate:

Navigate to /outlook-calendar/init/ in your browser. You’ll be redirected to Microsoft’s OAuth2 consent page.
Access Events:

After authentication, go to /outlook-calendar/events/ to view your Outlook Calendar events.

Conclusion

Integrating Outlook Calendar with your Django application using Microsoft Graph API enhances your app's scheduling capabilities, allowing you to create, view, and manage events directly within your app. This guide has shown you how to set up the necessary Azure credentials, implement the OAuth2 flow, and interact with the Outlook Calendar API.

By following these steps, you can now extend your integration to support additional calendar functionalities like event creation, updates, and synchronization. Ensure you handle tokens securely and include error handling to make your integration robust and reliable.

Connect Google Calendar to Django Application

Karanjot Singh — Thu, 15 Aug 2024 14:50:09 +0000

A Step-by-Step Guide to Seamlessly Integrate Google Calendar with Your Django Application for Enhanced Scheduling and Event Management.

Integrating Google Calendar with your Django application can significantly enhance your web app’s functionality by enabling scheduling, event management, and calendar synchronization. This guide will walk you through the steps to connect Google Calendar to your Django application, covering everything from setting up Google API credentials to implementing the necessary code in Django.

Prerequisites

Before you start, ensure you have the following:

1. Django Application: A working Django application.

2. Google API Console Account: Access to the Google Cloud Console.

3. Google Calendar API Enabled: The Google Calendar API should be enabled for your project in the Google Cloud Console.

Step 1: Set Up Google Cloud Project

1. Create a Project:
Go to the Google Cloud Console and create a new project.

2. Enable Google Calendar API:
Navigate to the “API & Services” > “Library” and search for “Google Calendar API.” Enable it for your project.

3. Configure Consent Screen:

Navigate to the “API & Services” > “OAuth consent screen” and configure the Consent screen.
Now select the type of OAuth you want (External in this case as the application would be accessible to anyone having a Google Account).
Set all the data for the consent screen like the App Name, logo, support email etc. as required.
Click on “Add or remove scopes” and add the following scopes, …/auth/userinfo.email , …/auth/userinfo.profile, openid to access user information and all the Google Calendar API scopes to access the Google calendar of user. Then click Update to save.
Next Add test users. Since our application is not yet verified by google hence only the users in this list would be able to register to this google project. So add all the test emails you would be using to test the google calendar integration. Once done continue to create credentials.

4. Create OAuth Credentials:
Go to “API & Services” > “Credentials” and create credentials. Select OAuth client ID as the type of credentials. Set Web application as the Application type and fill the application details.

Authorized redirect URIs: Add the redirect URL for your Django application (e.g., http://localhost:8000/oauth2callback for local development).

5. Download JSON Credentials:
Download the OAuth 2.0 credentials JSON file and keep it safe. This file contains your client_id, client_secret, and other important information.

Step 2: Install Required Python Packages

You’ll need a few Python packages to interact with Google APIs:

pip install google-auth google-auth-oauthlib google-auth-httplib2 google-api-python-client

Step 3: Configure Django Settings

Update your settings.py with the following:

import os

# Google Calendar API
GOOGLE_CLIENT_SECRETS_FILE = os.path.join(BASE_DIR, 'path/to/client_secret.json')
GOOGLE_API_SCOPES = ['https://www.googleapis.com/auth/calendar']
REDIRECT_URI = 'http://localhost:8000/oauth2callback'  # Or your production URL

Step 4: Create OAuth2 Flow

Create a view to handle the OAuth2 flow:

from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import Flow
from django.shortcuts import redirect
from django.http import HttpResponse
from django.conf import settings

def google_calendar_init(request):
    flow = Flow.from_client_secrets_file(
        settings.GOOGLE_CLIENT_SECRETS_FILE,
        scopes=settings.GOOGLE_API_SCOPES,
        redirect_uri=settings.REDIRECT_URI
    )
    authorization_url, state = flow.authorization_url(
        access_type='offline',
        include_granted_scopes='true'
    )

    request.session['state'] = state
    return redirect(authorization_url)

def google_calendar_redirect(request):
    state = request.session['state']

    flow = Flow.from_client_secrets_file(
        settings.GOOGLE_CLIENT_SECRETS_FILE,
        scopes=settings.GOOGLE_API_SCOPES,
        state=state,
        redirect_uri=settings.REDIRECT_URI
    )

    flow.fetch_token(authorization_response=request.build_absolute_uri())

    credentials = flow.credentials
    request.session['credentials'] = credentials_to_dict(credentials)

    return HttpResponse('Calendar integration complete. You can now use Google Calendar with your Django app.')

def credentials_to_dict(credentials):
    return {'token': credentials.token,
            'refresh_token': credentials.refresh_token,
            'token_uri': credentials.token_uri,
            'client_id': credentials.client_id,
            'client_secret': credentials.client_secret,
            'scopes': credentials.scopes}

Step 5: Handle Google Calendar API Requests

Once the OAuth2 flow is completed, you can make authenticated requests to Google Calendar API. Here’s a simple example to list the user’s calendar events:

from googleapiclient.discovery import build

def list_events(request):
    credentials = Credentials(**request.session['credentials'])
    service = build('calendar', 'v3', credentials=credentials)

    events_result = service.events().list(calendarId='primary', maxResults=10).execute()
    events = events_result.get('items', [])

    return HttpResponse(events)

Step 6: Update URLs

Add the URLs for the views in your urls.py:

from django.urls import path
from . import views

urlpatterns = [
    path('google-calendar/init/', views.google_calendar_init, name='google_calendar_init'),
    path('oauth2callback/', views.google_calendar_redirect, name='google_calendar_redirect'),
    path('google-calendar/events/', views.list_events, name='list_events'),
]

Step 7: Run and Test

Start Your Django Server:
Run your Django development server using python manage.py runserver.
Authenticate:
Navigate to /google-calendar/init/ in your browser. You’ll be redirected to Google’s OAuth2 consent page.
Access Events:
After authentication, go to /google-calendar/events/ to view your Google Calendar events.

Conclusion

Integrating Google Calendar with your Django application allows you to build powerful scheduling features directly within your app. By following this guide, you’ve set up OAuth2 authentication, connected to the Google Calendar API, and fetched calendar events. You can now expand this integration to include event creation, updates, and other calendar management features as needed.

PS: Remember to handle the credentials securely and ensure proper error handling for a robust application.

Blockchain Easily Explained

Karanjot Singh — Thu, 14 Apr 2022 19:33:10 +0000

What is a blockchain?

In simple words, blockchain is basically a database. But a very special one, one which is the most secure and impossible to hack as for now.

Blockchain is "unhackable" by its nature. Because instead of being on a computer like normal databases, blockchain is decentralized, which means it is stored on multiple devices across the globe. So to hack a blockchain one would need to hack into all the devices across the globe which is impossible as for now.

As for the developers, a blockchain collects information together in groups, known as blocks, that hold sets of information. Blocks have certain storage capacities and, when filled, are closed and linked to the previously filled block, just like a linked list, forming a chain of data known as the blockchain.

Blockchain vs Database

Criteria	Blockchain	Database
Authority	Decentralized: no central authority	Centralized: controlled by an admin
Architecture	Distributed Network	Client-Server
Integrity	Data can never be altered	Data can be altered
Data Handling	Only read and write operations are allowed	CRUD i.e. Create, Read, Update & Delete are allowed
Transparency	completely transparent	the admin decides who views the data
Performance	Slowed by the verification since data is stored on multiple devices	Extremely fast an scalable
Cost	Costly and harder to maintain	Cheaper to implement and maintain

So basically blockchain has a lot of advantages over normal databases but it is not better than it due to basic things like cost and performance.

Cryptocurrency: Blockchain's most popular application yet

Cryptocurrency, as you would already know, is just digital currency. Crypto uses blockchain as a base to store all the transactions. This was one of the best application of blockchain since transaction data needs to secure. No one should be able to change it. And this is the exact thing which blockchain does.

Conclusion (My thoughts)

So as for the answer of "Is blockain a future?". I think YES, it is. Blockchain is a very secure way to store our data. Also nowadays tech companies have become so big that people are stating to question their power. Blockchain is a way to decentralize the data away from these big companies.

Also as more and more people start adopting blockchain the prices will go down. More over technologies like Polygon sidechain also reduces cost and improves performance over normal blockchain. But that's a topic for another blog.

So Yes, according to me, blockchain could indeed be the future of data storing.

Cover Photo by Shubham Dhage on Unsplash

Thank you so much for reading my blog.
Know more about me @ karanjotsingh.com
Subscribe to my YouTube Channel CODE Infinite
Also follow me on Dev.to at karanjot_s

Starting Something New

Karanjot Singh — Wed, 30 Mar 2022 18:07:58 +0000

Introduction

Let me start by introducing myself. Hi, I'm Karanjot Singh, a developer, student and a tech enthusiast. This is my first blog post, so please ignore any mistake I have done. Also any recommendation is more than welcome in the comments.

Why I'm writing blogs

So, this blog is actually about why I'm writing blogs, in fact even this blog. So recently I have started a YouTube Channel CODE Infinite. Although I'm new to creating content to teach other people but I know that there are many people who want to learn from written content rather than videos. Everyone has his/her preferences so I'm not saying that one is better.

As I have seen writing a blog has many advantages both for readers who'll be viewing the blog and for writers.

First of all some people learn better by reading
Written content is easier to go through again. Like if you have already learned a skill and you want to revise it, it would be easier to read than to watch the whole video again.
As a content creator its much easier to write than to make a video, so I would be able to cover more topics in advance by writing than creating video.
I can also create blogs related to stuff I'm learning daily as a log or notes or whatever you want to call it.

Now I'm not saying that these are the only advantages or these things can't be done by videos. These are just the reason why I'm starting to create blogs.

My Plans

Now since this is dev.to, so its obvious that I'll be posting programming related stuff. So I have plans to post content related to following:

Tutorials
TWIL: This Week I Learned
Cheatsheets
And other stuff

Cover Photo by Ross Findon on Unsplash

Thank you so much for reading my blog.
Know more about me @ karanjotsingh.com
Subscribe to my YouTube Channel CODE Infinite
Also follow me on Dev.to at karanjot_s