Step by Step Guide to Building a Simpro API Integration in C#

Aug 18, 2024 • 7 minute read

Introduction

Hey there, fellow developer! Ready to dive into the world of Simpro API integration? You're in for a treat. Simpro's API is a powerful tool that'll let you tap into their job management system, and we're going to build that integration using C#. Buckle up!

Prerequisites

Before we jump in, make sure you've got:

Visual Studio or your favorite C# IDE
.NET Core SDK (latest version)
Simpro API credentials (if you don't have these, reach out to Simpro support)

Got all that? Great! Let's get coding.

Setting up the project

First things first, let's create a new C# project. Fire up Visual Studio, create a new Console Application, and name it something cool like "SimproIntegration".

Now, let's grab some NuGet packages we'll need:

Install-Package Newtonsoft.Json
Install-Package RestSharp

These will make our lives easier when dealing with JSON and HTTP requests.

Authentication

Simpro uses OAuth 2.0 for authentication. Here's a quick way to implement it:

using RestSharp;
using Newtonsoft.Json.Linq;

public class SimproAuth
{
    private string _accessToken;
    private DateTime _expiresAt;

    public async Task<string> GetAccessToken()
    {
        if (string.IsNullOrEmpty(_accessToken) || DateTime.Now >= _expiresAt)
        {
            await RefreshAccessToken();
        }
        return _accessToken;
    }

    private async Task RefreshAccessToken()
    {
        var client = new RestClient("https://api.simpro.co/oauth/token");
        var request = new RestRequest(Method.POST);
        request.AddParameter("grant_type", "client_credentials");
        request.AddParameter("client_id", "YOUR_CLIENT_ID");
        request.AddParameter("client_secret", "YOUR_CLIENT_SECRET");

        var response = await client.ExecuteAsync(request);
        var json = JObject.Parse(response.Content);

        _accessToken = json["access_token"].ToString();
        _expiresAt = DateTime.Now.AddSeconds(Convert.ToDouble(json["expires_in"]));
    }
}

Remember to replace YOUR_CLIENT_ID and YOUR_CLIENT_SECRET with your actual credentials!

Making API requests

Now that we've got authentication sorted, let's make some requests:

public class SimproApi
{
    private readonly SimproAuth _auth;
    private readonly string _baseUrl = "https://api.simpro.co";

    public SimproApi(SimproAuth auth)
    {
        _auth = auth;
    }

    public async Task<string> GetCustomers()
    {
        var client = new RestClient(_baseUrl);
        var request = new RestRequest("/customers", Method.GET);
        request.AddHeader("Authorization", $"Bearer {await _auth.GetAccessToken()}");

        var response = await client.ExecuteAsync(request);
        return response.Content;
    }

    // Add similar methods for POST, PUT, DELETE...
}

Working with Simpro resources

You can create similar methods for other Simpro resources like Jobs and Invoices. The structure will be pretty much the same, just change the endpoint.

Error handling and logging

Don't forget to wrap your API calls in try-catch blocks and log any errors:

try
{
    var customers = await _simproApi.GetCustomers();
    // Process customers...
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
    // Log the error...
}

Best practices

Respect rate limits: Simpro might have restrictions on how many requests you can make in a given time period.
Use pagination: If you're dealing with large datasets, use Simpro's pagination features to avoid timeouts.
Cache data when possible to reduce API calls.

Testing the integration

Write unit tests for your methods and integration tests to ensure everything's working as expected. Here's a simple example using xUnit:

[Fact]
public async Task GetCustomers_ReturnsCustomers()
{
    var auth = new SimproAuth();
    var api = new SimproApi(auth);

    var result = await api.GetCustomers();

    Assert.NotNull(result);
    Assert.Contains("customers", result);
}

Deployment considerations

When deploying your integration:

Store your API credentials securely (use environment variables or a secure key vault)
Consider implementing retry logic for failed requests
Monitor your application's performance and API usage

Conclusion

And there you have it! You've just built a Simpro API integration in C#. Pretty cool, right? Remember, this is just the beginning. There's a lot more you can do with the Simpro API, so keep exploring and building awesome stuff!

Additional resources

Happy coding, and may your integration be ever successful!