On the first iteration of a project of mine, I wanted to access Google Tasks using Ruby. Therefore, I did a little bit of tinkering with using the Google Tasks API using Ruby. In this post, I will go over your project’s setup, the Google backend setup and the basic usage of the API.
Project Setup
All of the Google Tasks APIs are basically REST endpoints. One could simply call all these HTTP endpoints manually, but this would be painful. I decided to use google-api-client to do all the heavy lifting. In order to include it in your project, simply add the following to your Gemfile:
|
1 |
gem 'google-api-client', '~> 0.11' |
Google API Setup
In order to access Google Tasks using Ruby, you will need to use Google’s OAuth. Google’s OAuth uses what they call client secrets file. These files contain all the information needed to access the selected services.
To get a client secrets file, you can follow my other post.
Handling the user’s credentials
The way the Google APIs work, an URL will be provided to you. Opening that URL and grabbing the authentication token is all on you. Therefore, there is three consideration when handling the user’s credential:
- Storing the credentials (so that you don’t ask access every time);
- Showing the consent webpage;
- Grabbing the authentication token;
For this quick test, I decided to use a file storage for the token. The FileTokenStore token store will simply use a YAML file to store the user’s tokens. To show the consent webpage, I went with launchy. This cross-platform library will handle opening URLs in the default browser and such. Finally, I decided to basically do nothing to grab the token: I expect the user to paste it on the command line.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
require 'googleauth' require 'googleauth/stores/file_token_store' require 'launchy' OOB_URI = 'urn:ietf:wg:oauth:2.0:oob' scope = 'https://www.googleapis.com/auth/tasks' client_id = Google::Auth::ClientId.from_file('./client_secrets.json') token_store = Google::Auth::Stores::FileTokenStore.new(:file => './tokens.yaml') authorizer = Google::Auth::UserAuthorizer.new(client_id, scope, token_store) user_id = 'default' credentials = authorizer.get_credentials(user_id) if credentials.nil? url = authorizer.get_authorization_url(base_url: OOB_URI ) Launchy.open(url) code = gets credentials = authorizer.get_and_store_credentials_from_code(user_id: user_id, code: code, base_url: OOB_URI) end |
Initializing the Google Tasks API
Now that you have the user’s credentials, you can initialize the API you want to use. In my case, this is the task API. In order to do so, simply create a new instance of the service you want to use (Google::Apis::TasksV1::TasksService) and set its authorization member to the credentials you got from the client.
|
1 2 3 4 5 6 7 |
require 'google/apis/tasks_v1' [snip] Tasks = Google::Apis::TasksV1 # Alias the module tasks_service = Tasks::TasksService.new tasks_service.authorization = credentials |
Interacting with Google Tasks using Ruby
Creating a task list
The tasklist is basically a grouping of tasks. It is the root concept of Google Tasks. Creating one is quite straightforward:
|
1 2 3 |
tasklist = tasks_service.insert_tasklist( Tasks::TaskList.new(title:'generated') ) |
Finding a task list
The Google Tasks API only allows you to search by tasklist ID, not a title. This ID is automatically generated and therefore not really easy to use. The easiest way to find a task list is to list all task lists and find the one you are looking for in there:
|
1 2 |
tasklists = tasks_service.list_tasklists tasklist = tasklists.items.find { |t| t.title == 'generated' } |
Creating a task
Creating a simple task, at the top of the task list is quite straightforward:
|
1 2 3 4 |
task = tasks_service.insert_task( tasklist.id, Tasks::Task.new(title:'generated') ) |
Finding a task
Just like finding a task list, finding a task by its title can’t be done directly through the API. In order to do so, you need to iterate over the tasks and check them:
|
1 2 |
tasks = tasks_service.list_tasks(tasklist.id) task = tasks.items.nil? ? nil : tasks.items.find { |t| t.title == 'generated' } |
Updating a task
Once you have your hand on the task you want to update, simply update the field you want to update and call update_task:
|
1 2 |
task.due = DateTime.new(2020,2,3,4,5,6) task = tasks_service.update_task(tasklist.id, task.id, task) |
Completing a task
Completing a task is done by setting its status to “completed” and updating the task:
|
1 2 |
task.status = "completed" task = tasks_service.update_task(tasklist.id, task.id, task) |
Handling a large number of return values
Google’s Task API uses pagination in order to handle a large number of return values. By default, a maximum of 100 return values will be returned by calls to list_tasklists and list_tasks. The return values of these two APIs will contain a next_page_token value. You can then use this token in a subsequent call to the API specifying the optional argument page_token in order to get another set of return values.
Here is a quick example of handling of pagination with the list_tasks call. Do note that in this example, I set the max_results value in the call so that I do not have to create 100+ tasks.
|
1 2 3 4 5 6 7 8 |
tasklists = tasks_service.list_tasklists tasklist = tasklists.items.find { |t| t.title == 'overflow' } token = nil begin tasks = tasks_service.list_tasks(tasklist.id, max_results: 10, page_token: token) puts "Found #{tasks.items.size} tasks" token = tasks.next_page_token end while not token.nil? |