Step by Step Guide to Building a Wrike API Integration in Go

Aug 16, 2024 • 7 minute read

Introduction

Hey there, fellow Go enthusiast! Ready to supercharge your project management with Wrike's powerful API? In this guide, we'll walk through building a robust Wrike API integration using Go. We'll be leveraging the awesome github.com/pierreboissinot/go-wrike package to make our lives easier. Let's dive in!

Prerequisites

Before we start coding, make sure you've got:

Go installed on your machine
A Wrike account with an API token
A solid grasp of Go basics and RESTful APIs

Got all that? Great! Let's get our hands dirty.

Setting up the project

First things first, let's create a new Go module:

mkdir wrike-integration && cd wrike-integration
go mod init wrike-integration

Now, let's grab the go-wrike package:

go get github.com/pierreboissinot/go-wrike

Initializing the Wrike client

Time to write some Go! Create a new file called main.go and add this:

package main

import (
    "fmt"
    "github.com/pierreboissinot/go-wrike"
)

func main() {
    client := wrike.NewClient("YOUR_API_TOKEN")
    // We'll add more code here soon!
}

Replace YOUR_API_TOKEN with your actual Wrike API token. Easy, right?

Basic API operations

Let's start with some basic operations. We'll fetch workspaces, retrieve tasks, and create a new task.

Fetching workspaces

workspaces, err := client.Workspaces.GetAll()
if err != nil {
    fmt.Printf("Error fetching workspaces: %v\n", err)
    return
}
fmt.Printf("Found %d workspaces\n", len(workspaces))

Retrieving tasks

tasks, err := client.Tasks.GetAll()
if err != nil {
    fmt.Printf("Error fetching tasks: %v\n", err)
    return
}
fmt.Printf("Found %d tasks\n", len(tasks))

Creating a new task

newTask, err := client.Tasks.Create(&wrike.TaskParams{
    Title: "My awesome new task",
    Description: "This task was created via the Go Wrike API!",
})
if err != nil {
    fmt.Printf("Error creating task: %v\n", err)
    return
}
fmt.Printf("Created task with ID: %s\n", newTask.ID)

Advanced usage

Now that we've got the basics down, let's tackle some more advanced operations.

Updating task status

updatedTask, err := client.Tasks.Update(newTask.ID, &wrike.TaskParams{
    Status: "Completed",
})
if err != nil {
    fmt.Printf("Error updating task: %v\n", err)
    return
}
fmt.Printf("Updated task status to: %s\n", updatedTask.Status)

Adding comments to tasks

comment, err := client.Comments.Create(newTask.ID, &wrike.CommentParams{
    Text: "Great job on this task!",
})
if err != nil {
    fmt.Printf("Error adding comment: %v\n", err)
    return
}
fmt.Printf("Added comment with ID: %s\n", comment.ID)

Handling attachments

attachment, err := client.Attachments.Create(newTask.ID, "path/to/file.pdf")
if err != nil {
    fmt.Printf("Error uploading attachment: %v\n", err)
    return
}
fmt.Printf("Uploaded attachment with ID: %s\n", attachment.ID)

Error handling and best practices

When working with APIs, always be prepared for things to go wrong. Here are some tips:

Check for rate limits in the API response headers.
Use proper error checking (as we've done in the examples above).
Implement exponential backoff for retries on failed requests.

Testing the integration

Don't forget to test your integration! Here's a quick example of a unit test:

func TestCreateTask(t *testing.T) {
    client := wrike.NewClient("TEST_TOKEN")
    task, err := client.Tasks.Create(&wrike.TaskParams{
        Title: "Test Task",
    })
    if err != nil {
        t.Fatalf("Failed to create task: %v", err)
    }
    if task.Title != "Test Task" {
        t.Errorf("Expected task title 'Test Task', got '%s'", task.Title)
    }
}

For more complex scenarios, consider mocking API responses to test edge cases and error handling.

Conclusion

And there you have it! You've just built a solid Wrike API integration using Go. We've covered the basics, dove into some advanced features, and even touched on testing. The sky's the limit from here – why not try integrating more of Wrike's features into your Go projects?

Resources

Happy coding, and may your tasks always be on time and under budget!