Digital calendars are essential for everyone. Whether it’s for scheduling, organizing, or attending events, calendars are critical for companies and individuals alike. Nylas makes it possible to bring calendaring features to your application with our universal Calendar API that works across most major providers.
To make things even easier for Ruby developers, we offer the Nylas Ruby SDK. Today we’re going to review how to manage calendar events with Ruby using the SDK.
If you already have the Nylas Ruby SDK installed and your environment is configured, go ahead and proceed to the next section.
Otherwise, I would recommend you to read the post How to Send Emails with the Nylas Ruby SDK where the basic setup is explained.
Now we get to write some code! For my code editor, I’m going to use Geany, however, you can use the IDE of your choice.
Let’s start by reading a list of our calendars, looking at calendar id, name, and description. We’re going to call this file ReadCalendars.rb:
Email API
Calendar API
Scheduler
Contacts API
ExtractAI
Google email & calendar integration
Outlook email & calendar integration
IMAP integration
Calendar management
Embedded contextual email
Scheduling automation
Automated outreach
Intelligent data extraction
Ecommerce
Telehealth
Real estate
Financial technology
Educational technology
Expense management
Customer relationship management
Applicant tracking system
Communications platform
Marketplaces
Document management
Docs
SDKs
Tutorials
API status
Changelog
Support
Blog
Events
Guides
Inspiration gallery
Partners
Build vs. buy
Customer stories
Security & Compliance
Why Nylas
Newsroom# Import your dependencies
require 'dotenv/load'
require 'nylas'
# Initialize your Nylas API client
nylas = Nylas::API.new(
app_id: ENV["CLIENT_ID"],
app_secret: ENV["CLIENT_SECRET"],
access_token: ENV["ACCESS_TOKEN"]
)
# Access and print all calendars information
calendars = nylas.calendars
calendars.each{ |calendar|
puts(
"Id: #{calendar.id} | "\
"Name: #{calendar.name} | "\
"Description: #{calendar.description}"
)
}
We can run this script from the terminal by using:
$ ruby ReadCalendars.rb
As we can see, we’re going to get back a list of all the available calendars for our account.
Note that each of the calendars returned has an id. You’ll need at least one of those ids in the following steps.
One advantage of being able to read a Calendar is being able to see events in our schedule, so that’s what we’re going to do now. We’re going to choose a Calendar and read its related events.
For that, we’re going to create a new file called ReadEvents.rb (be sure to add a calendar id from the previous section to the code below):
# Import your dependencies
require 'dotenv/load'
require 'nylas'
# Initialize your Nylas API client
nylas = Nylas::API.new(
app_id: ENV["CLIENT_ID"],
app_secret: ENV["CLIENT_SECRET"],
access_token: ENV["ACCESS_TOKEN"]
)
# Access and print all calendars information
events = nylas.events.where(calendar_id: "<YOUR_CALENDAR_ID>")
events.each{ |event|
if event.when.start_time
print(
"Title: #{event.title} | " \
"Start: #{event.when.start_time} | " \
"End: #{event.when.end_time} | " \
"Participants: ["
)
else
print(
"Title: #{event.title} | " \
"Date: #{event.when.date} | " \
"Participants: ["
)
end
event.participants.each{ |participant|
print (
"{comment: #{participant.comment}, " \
"email: #{participant.email}, " \
"name: #{participant.name}, " \
"status: #{participant.status}}"
)
}
puts("]\n")
}
We can run this script from the terminal by using:
$ ruby ReadEvents.rb
Reading events is important, but maybe there’s something more important, which is the ability to create events.
Let’s make a new script that creates a new event on our calendar. We’re going to name this file CreateEvent.rb (be sure to add your calendar id from the previous section, as well as your email address, to the code below):
# Import your dependencies
require 'dotenv/load'
require 'nylas'
require 'date'
# Initialize your Nylas API client
nylas = Nylas::API.new(
app_id: ENV["CLIENT_ID"],
app_secret: ENV["CLIENT_SECRET"],
access_token: ENV["ACCESS_TOKEN"]
)
# Get today’s date
today = Date.today
# Access and print all calendars information
event = nylas.events.create(title: "Let's learn some Nylas Ruby API!", location: "Blag's Den!", when: { start_time: Time.local(today.year, today.month, today.day, 10, 0,0).strftime("%s"), end_time: Time.local(today.year, today.month, today.day, 12, 0,0).strftime("%s") }, participants: [{name: "Blag", email: "<your_email>"}], calendar_id: "<your_calendar_id>", notify_participants: true)
if event.id
puts 'Event created successfully'
else
puts 'There was an error creating the event'
end
We can run this script from the terminal by using:
$ ruby CreateEvent.rb
And we can see that the event was successfully created.
We will get an email notification and it will appear on our calendar as well.
We have reviewed how to create an event rather quickly.
Sometimes, we might realize that we forgot to add something to the invite, or maybe the time of our event has changed. We’ll need to update the event we just created.
In order to do that, we need to have the event id. If we modify our ReadEvents.rb script slightly, we can easily get the id:
# Import your dependencies
require 'dotenv/load'
require 'nylas'
require 'date'
# Initialize your Nylas API client
nylas = Nylas::API.new(
app_id: ENV["CLIENT_ID"],
app_secret: ENV["CLIENT_SECRET"],
access_token: ENV["ACCESS_TOKEN"]
)
# Get today’s date
today = Date.today
# Today’s date at 12:00:00 am
_START = Time.local(today.year, today.month, today.day, 0, 0, 0).strftime("%s")
# Today’s date at 11:59:59 pm
_END = Time.local(today.year, today.month, today.day, 23, 59, 59).strftime("%s")
# Access and print all calendars information
events = nylas.events.where(calendar_id: "<your_calendar_id>", starts_after: _START,ends_before: _END)
events.each{ |event|
if event.when.start_time
print(
"Id: #{event.id} | " \
"Title: #{event.title} | " \
"Start: #{event.when.start_time} | " \
"End: #{event.when.end_time} | " \
"Participants: ["
)
else
print(
"Id: #{event.id} | " \
"Title: #{event.title} | " \
"Date: #{event.when.date} | " \
"Participants: ["
)
end
event.participants.each{ |participant|
print (
"{comment: #{participant.comment}, " \
"email: #{participant.email}, " \
"name: #{participant.name}, " \
"status: #{participant.status}}"
)
}
puts("]\n")
}
We can run this script from the terminal by using:
$ ruby ReadEvents.rb
Once we have the corresponding event id we can create a new script and call it UpdateEvent.rb, where we use the event id to update the event:
# Import your dependencies
require 'dotenv/load'
require 'nylas'
require 'date'
# Initialize your Nylas API client
nylas = Nylas::API.new(
app_id: ENV["CLIENT_ID"],
app_secret: ENV["CLIENT_SECRET"],
access_token: ENV["ACCESS_TOKEN"]
)
# Get today’s date
today = Date.today
# Today’s date at 12:00:00 am
_START = Time.local(today.year, today.month, today.day, 12, 0, 0).strftime("%s")
# Today’s date at 11:59:59 pm
_END = Time.local(today.year, today.month, today.day, 14, 0, 0).strftime("%s")
# Get the event information
event = nylas.events.find("<your_event_id>")
# Update the event information
event.update(when: { start_time: _START,
end_time: _END })
if event.id
puts 'Event updated successfully'
else
puts 'There was an error creating the event'
end
We can run this script from the terminal by using:
$ ruby UpdateEvent.rb
We get an email about the event update:
And the event in the calendar is going to be updated as well:
As we’ve seen here, updating an event is very similar to creating one. The Nylas Ruby SDK is flexible enough to make working with events simple and straightforward.
Just for the sake of completion and taking advantage of the fact that we have the event id, let’s create a quick script to delete events.
We’re going to create this file called DeleteEvent.rb, using the event id:
# Import your dependencies
require 'dotenv/load'
require 'nylas'
# Initialize your Nylas API client
nylas = Nylas::API.new(
app_id: ENV["CLIENT_ID"],
app_secret: ENV["CLIENT_SECRET"],
access_token: ENV["ACCESS_TOKEN"]
)
# Get the event information
event = nylas.events.find("<your_event_id")
# Delete the event
event.destroy
# Verify that the event was deleted
begin
event = nylas.events.find("<your_event_id>")
rescue => error
puts 'There was an error deleting the event'
else
puts 'Event deleted successfully'
end
… and run the file:
$ ruby DeleteEvent.rb
We will get an email notification and the event will be removed from our calendar
And that’s it! As you can see, by using the Nylas Ruby SDK, working with calendar events becomes an easy task. If you want to learn more, visit our Documentation Page.
We’re excited to announce the launch of the Nylas Scheduler v3! Efficient scheduling is essential…
Key Takeaways Managing calendar availability is essential for professionals, teams, and businesses to stay organized…
Key Takeaways This article addresses the challenges of webhook integration and introduces the PubSub Notification…
Blag aka Alvaro Tejada Galindo is a Senior Developer Advocate at Nylas. He loves learning about programming and sharing knowledge with the community. When he’s not coding, he’s spending time with his wife, daughter and son. He loves Punk Music and reading all sorts of books.