Hello and welcome to another Kaizen week!
In this week's post, we'll show you how to get started with Zoho CRM's Scala SDK, and walk you through the configuration and initialization process. Specifically, we will discuss how to use the
Scala SDK to make API calls authenticated via self-client. Please note that this article holds true for Scala SDK supporting version 6 of Zoho CRM APIs.
Software Development Kits (SDKs) are sets of tools and libraries designed to simplify the development process, and the integration between applications and specific platforms or services. They provide pre-built functionalities and abstract complex tasks, facilitating easier and faster development process. Zoho CRM's Scala SDKs act as a wrapper for the
REST APIs, thus making it easier to use the services of Zoho CRM.
Simplified Authentication using Scala SDK
Authentication with Zoho CRM APIs is facilitated by the OAuth 2.0 protocol, ensuring secure access to its resources. The process begins with the
generation of a grant token for your organization in the Zoho Developer Console, where you specify the required scopes. Subsequently, using this grant token, you can
generate both the access token, used for API call authentication, and the refresh token, employed for
refreshing the access tokens after their one-hour expiry period. You must persist these tokens, along with their expiry times, in your server's data store for seamless API access.
However, with the Scala SDK, this authentication process is significantly simplified. After generating the grant token and initialization, the SDK takes care of the rest. The SDK handles token generation, persistence, and refreshing the access token automatically, ensuring access to the resources without manual intervention.
Using the Zoho CRM Scala SDK
Before diving into the usage of Scala SDKs, ensure that the following prerequisites are met:
- Ensure that the client app has Java version 11 or above.
- Ensure that the client app has Scala version 2.13.5 or above.
- Have an IDE such as IntelliJ installed.
- An active Zoho CRM account.
1. Register your application with Zoho CRM
When you register a client with Zoho CRM, you establish a connection between your application and Zoho CRM, enabling your application to securely access and interact with Zoho CRM APIs and resources after authentication. The registration process involves providing essential details such as the client type, homepage URL, and authorized redirect URIs, depending on the type of client you choose.
To register your client:
- Go to the Zoho Developer Console
- Click on Get Started or +ADD CLIENT
- Choose the Client Type as Self-Client or Server based Applications depending on your application. Read our Kaizen post on the different client types to understand better. For this article, we will proceed with Self-client as we aim to develop a Scala application for our own use.
- Fill in the necessary details and click CREATE to register your client successfully. This will provide you with a Client ID and Client Secret.
2. Create a Scala project in your preferred IDE
If you already have your project set up, you may skip this step. However, if you are starting out, the next crucial step is to create a Scala Project in your preferred IDE. For the purpose of this guide, we will be using IntelliJ IDEA as the IDE of choice.
3. Include the Zoho CRM Scala SDK in your project
To include the Zoho CRM Scala SDK in your project, you can follow different methods as outlined
here. However, for the purpose of this guide, we will demonstrate how to include the SDK using the
build.sbt file.
Follow these steps to include the Zoho CRM Scala SDK in your project using the build.sbt file:
- Open your project in IntelliJ IDEA or your preferred IDE.
- Locate the build.sbt file in your project directory.
- Add the Zoho CRM Scala SDK dependency to your build.sbt file. To add the latest version (supporting version 6 of Zoho CRM APIs), include this line in the file and Save: libraryDependencies ++= Seq( "com.zoho.crm" % "zohocrmsdk-6-0" % "2.0.0")
- Sync the changes and reload the files to ensure that the SDK has been added to the project.
Please note that when you install the Zoho CRM SDK, there are many dependencies which will also be installed. These dependencies are necessary for the proper functioning of the SDK and will be automatically managed by your build tool (such as sbt) during the installation process.
4. Obtain the grant token to authenticate your client
To make API calls, you need to authenticate your client by generating a grant token with the required scopes. For this guide, we will be using the self-client created in the first step.
Log in to the
Zoho Developer Console, and generate the grant token with the required scopes. Please note that this grant token has a short life span, and that it is used to generate the access and refresh tokens. Refer to our
Kaizen on OAuth2.0 for more details.
5. Configuration and Initialization of the SDK
The configuration step in initializing the SDK involves setting up various objects to define how the SDK operates. This includes specifying the domain for API calls, token persistence, error logging, resource information storage, and more.
Before going into the specifics of various configurations, let us first discuss Token Persistence. Token Persistence refers to the mechanism through which access tokens and refresh tokens obtained during authentication are stored and managed by the SDK. By storing tokens securely, the SDK can automatically manage token expiration and renewal, eliminating the need for manual token handling by the developer.For details on the different persistence methods supported by our SDKs, please refer to the last section of this post. In this guide, we will be using File Persistence as the method for Token Persistence. However, please note that users must choose the method that best suits their requirements and preferences.
Here is a sample code to initialize the SDK. Make sure to replace the client ID, client secret, grantToken, file paths, and other configurations with your specific values.
During the initialization step, the following configuration details have to be defined to configure the behavior and functionality of the SDK. While two of them are mandatory, the others are optional.
- environment (mandatory): It determines the API environment, which dictates the domain and URL for making API calls. The format follows the Domain.Environment pattern.
eg : val env = USDataCenter.PRODUCTION - token (mandatory) : Contains the user token details. Create an instance of OAuthToken with the details that you get after registering your Zoho client. Depending on the available tokens, you can select one of the following flows:
- Grant Token Flow: Involves storing and persisting the grant token. This flow is used when you have a grant token available. The SDK will generate and persist the access and refresh tokens, and also refresh the access token upon expiry.
- Refresh Token Flow: Involves storing and persisting the refresh token. This flow is used when you have a refresh token available. The SDK will generate and persist the access and refresh tokens, and also refresh the access token upon expiry.
- Access Token Flow: In this flow, the access token is directly utilized for API calls without token persistence. The SDK will persist the access token, but upon expiry it won't be refreshed, and an INVALID_TOKEN error will be thrown once the access token has expired.
- Id FLow : You can use the id from the persisted token file/DB to make API calls. The id is a unique system generated value for each token details entry in the file/DB. Please note that you can use this method only after the SDK has already been initialized.
- logger (optional) : You can customize the logging behavior by setting the desired log level, which can be one of the following: FATAL, ERROR, WARNING, INFO, DEBUG, TRACE, ALL, or OFF. Additionally, you can configure the file path and file name for the log file.
store (optional) : Allows you to configure token persistence for your application. If this is skipped, the SDK will create the "sdk_tokens.txt" file in the current working directory by default to persist the tokens.
Database Persistence | File Persistence | Custom Persistence |
var tokenstore = new DBStore.Builder() .host("hostName") .databaseName("databaseName") .tableName("tableName") .userName("userName") .password("password") .portNumber("portNumber") .build | var tokenstore = new FileStore("/Users/user_name/Documents/scala_sdk_token.txt") | var tokenStore = new CustomStore() |
SDKConfig (optional) : This method takes care of additional SDK configurations.
Configuration Key | Description |
autoRefreshFields Default Value : False | A boolean configuration field to enable or disable automatic refreshing of module fields in the background. If set to true, fields are refreshed every hour, and if set to false, fields must be manually refreshed or deleted. |
pickListValidation Default Value : True | This field enables or disables pick list validation. If enabled, user input for pick list fields is validated, and if the value does not exist in the pick list, the SDK throws an error. If disabled, the input is not validated and the API call is made. |
enableSSLVerification Default Value : True | A boolean field to enable or disable curl certificate verification. If set to true, the SDK verifies the authenticity of certificate. If set to false, the SDK skips the verification. |
connectionTimeout Default Value : 0 | The maximum time (in seconds) to wait while trying to connect. Use 0 to wait indefinitely. |
| The maximum time (in seconds) to allow cURL functions to execute. Use 0 to wait indefinitely. |
requestProxy (optional) : Configure this only if you're using a proxy server to make the API calls. To configure, create an instance of RequestProxy containing the proxy properties of the user.
var requestProxy = new RequestProxy.Builder() .host("proxyHost") .port(80) .user("proxyUser") .password("password") .userDomain("userDomain") .build() |
- resourcePath (optional) : To configure the absolute directory path to store user-specific files containing module fields information. If this object is skipped, the files will be stored in the project directory itself.
Once the initialization is successful, you can verify that the access and refresh tokens are generated and persisted. You can do this by checking the tokens file or the database, depending on the token persistence method you configured during initialization.