zoho_hub 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb0b0886637feb21a98d0a73f40cb3571a0ec2507dfd45b7eec9fd348b365276
-  data.tar.gz: 70638084911ec64dc02095d4cf085453ca13ba4ea28a3c983c79e235a1a5911e
+  metadata.gz: e1967126d56677efb3373c3a3d8700842f5d03e0f3b0cb922b4ffcf5d113a831
+  data.tar.gz: 1cf0f3e67da7d878dd367614c3da7441d0024fe070dae978f72e49575e6be013
 SHA512:
-  metadata.gz: c5fc255597ced5c966a59b0db9de72ab6a67defca6c1a62e5e168f37bc70326f2c1cccd5cf3ab44369a94372277ca42c671965e50d742b315b26126882f1af72
-  data.tar.gz: 89fbe288d53b9ebf9c76f8229981deffcacc9d6fe484b6187f654430eb097c7e1b57719dafcc953cafbfafeec7f1d765c87794697b3d283b168cbd2c9f35ff03
+  metadata.gz: 203045fd8b960ae3dd03873106ea7a88a111bbd6618d9942e9c597cdef83ba860792639e13e92b7a32ad0d550b9521795ab8c4043dc8e9e2de44321a5e2a7990
+  data.tar.gz: ac2a1e1e7bca5a28196d9cdc68312c1a8774ddc1666266a0a4956587b482bf255da15aa50f9c05cb593a6768103f3b939a91ed692c16641cd26976ce51f63243

data/.rubocop.yml

@@ -33,11 +33,3 @@ RSpec/ExampleLength:
 
 RSpec/MultipleExpectations:
   Max: 10
-
-RSpec/RepeatedExample:
-  Exclude:
-    - 'spec/policies/**/*'
-
-RSpec/RepeatedDescription:
-  Exclude:
-    - 'spec/policies/**/*'

data/README.md

@@ -3,7 +3,7 @@
 [![Build Status](https://travis-ci.com/rikas/zoho_hub.svg?branch=master)](https://travis-ci.com/rikas/zoho_hub)
 [![Gem Version](https://badge.fury.io/rb/zoho_hub.svg)](https://badge.fury.io/rb/zoho_hub)
 
-Simple wrapper around Zoho CRM version2, using [OAuth 2.0 protocol](https://www.zoho.com/crm/help/api/v2/#OAuth2_0)
+Simple wrapper around Zoho CRM version2, using [OAuth 2.0 protocol](https://www.zoho.com/crm/help/developer/api/oauth-overview.html)
 for authentication.
 
 This gem reads your Module configuration and builds the corresponding classes for you, using some
@@ -33,32 +33,59 @@ Or install it yourself as:
 ### 1. Register your application
 
 If you want to access your Zoho CRM account from your application you first need to create your
-application as described here: https://www.zoho.com/crm/help/api/v2/#oauth-request.
+application as described here: https://www.zoho.com/crm/help/developer/api/register-client.html.
 
-**TODO TODO - explain "Authorized redirect URIs"**
+This will give you a **Client ID** and a **secret**, that you'll use in step 2.
 
-This will give you a **Client ID** and a **secret**, that you'll use in the next step.
+#### 1.1 Zoho Accounts URL
+
+Registration and authorization requests are made to Zoho's domain-specific Accounts URL which
+varies depending on your region:
+
+* EU: https://accounts.zoho.eu
+* US: https://accounts.zoho.com
+* China: https://accounts.zoho.com.cn
+
+ZohoHub uses the EU Account URL by default, but this can be overriden in a `ZohoHub.configure`
+block via the `api_domain` method (see step 2.)
+
+#### 1.2 Authorized Redirect URI
+
+Per Zoho's API documentation, providing a **redirect URI** is optional. Doing so allows a user of
+your application to be redirected back to your app (to the **redirect URI**) with a **grant token**
+upon successful authentication.
+
+If you don't provide a **redirect URI**, you'll need to use the [self-client option](https://www.zoho.com/crm/help/developer/api/auth-request.html#plink2)
+for authorization (see 3.2 below.)
 
 ### 2. Configure ZohoHub with your credentials
 
+> **Note:** Treat these credentials like an important password. It is *strongly* recommended to not
+> paste them anywhere in plain text. Do *not* add them to version control; keep them out of your
+> code directly by referencing them via environment variables. Use something like the dotenv gem or
+> encrypted credentials in Rails to keep them as secret and secure as possible.
+
 You need to have a configuration block like the one below (in rails add a `zoho_hub.rb` in your
-`config/initializers` dir):
+`config/initializers` directory):
 
 ```ruby
 ZohoHub.configure do |config|
   config.client_id    = 'YOUR_ZOHO_CLIENT_ID' # obtained in 1.
   config.secret       = 'YOUR_ZOHO_SECRET'    # obtained in 1.
   config.redirect_uri = 'YOUR_ZOHO_OAUTH_REDIRECT_URL'
+  config.api_domain   = 'https://accounts.zoho.com' # can be omitted if in the EU
   # config.debug      = true # this will be VERY verbose, but helps to identify bugs / problems
 end
 ```
 
-**Note:** if you don't know what the `redirect_url` is then **TODO TODO TODO TODO TODO**
-
-### 2. Authorization request
+### 3. Authorization request
 
 In order to access data in Zoho CRM you need to authorize ZohoHub to access your account. To do so
-you have to request a specific URL with the right **scope** and **access_type**.
+you have to request a specific URL with the right **scope** and **access_type**. Successful
+authorization will provide a **grant token** which will be used to generate **access** and
+**refresh tokens**.
+
+#### 3.1 Redirection based authentication
 
 To get the right URL you can use this simple line of code:
 
@@ -71,6 +98,22 @@ If you request this generated URL you should see a screen like this one, where y
 
 ![](https://duaw26jehqd4r.cloudfront.net/items/1h1i3C1N0k0i02092F0S/Screen%20Shot%202018-11-25%20at%2019.18.38.png)
 
+You will then be redirected to the **redirect URI** you provided with additional query parameters
+as follows (the value after `code=` is the **grant token**):
+
+```
+{redirect_uri}?code={grant_token}&location=us&accounts-server=https%3A%2F%2Faccounts.zoho.com
+```
+
+#### 3.2 Self-Client Authorization
+
+If you don't have a **redirect URI** or you want your application to be able to authorize with Zoho
+programmatically (without a user required to be present and click the "Accept" prompt), Zoho
+provides a [self-client option](https://www.zoho.com/crm/help/developer/api/auth-request.html#plink2)
+for authentication which will provide a **grant token**.
+
+#### 3.3 More on scopes
+
 You can change the default scope (what data can be accessed by your application). This is the list
 provided as the default scope:
 
@@ -88,13 +131,15 @@ ZohoHub::Auth.auth_url(scope: ['ZohoCRM.modules.custom.all', 'ZohoCRM.modules.al
 # => "https://accounts.zoho.eu/oauth/v2/auth?access_type=offline&client_id=&redirect_uri=&response_type=code&scope=ZohoCRM.modules.custom.all,ZohoCRM.modules.all"
 ```
 
-#### 2.1 Offline access
+Refer to [Zoho's API documentation on scopes](https://www.zoho.com/crm/help/developer/api/oauth-overview.html#plink5) for detailed information.
 
-By design the access tokens returned by the OAuth flow expire after a period of time (1 hour by
+#### 3.4 Offline access
+
+By design the **access tokens** returned by the OAuth flow expire after a period of time (1 hour by
 default), as a safety mechanism. This means that any application that wants to work with a user's
 data needs the user to have recently gone through the OAuth flow, aka be online.
 
-When you request offline access the Zoho API returns a refresh token. Refresh tokens give your
+When you request offline access the Zoho API returns a **refresh token**. **Refresh tokens** give your
 application the ability to request data on behalf of the user when the user is not present and in
 front of your application.
 
@@ -107,7 +152,109 @@ ZohoHub::Auth.auth_url(access_type: 'online')
 # => "https://accounts.zoho.eu/oauth/v2/auth?access_type=online&client_id=&redirect_uri=&response_type=code&scope=ZohoCRM.modules.custom.all,ZohoCRM.settings.all,ZohoCRM.modules.contacts.all,ZohoCRM.modules.all"
 ```
 
-## 3. Generate Access Token
+### 4. Access token
+
+See Zoho's API documentation for generating an initial **access token**:
+https://www.zoho.com/crm/help/developer/api/access-refresh.html
+
+To use an **access token** in a manual request, include it as a request header as
+`Authorization: Zoho-oauthtoken {access_token}` (without the braces.)
+
+To use an **access token** with ZohoHub, pass it to the `ZohoHub.setup_connection` method as the
+`access_token` parameter.
+
+
+### 5. Refresh token
+
+TODO
+
+### 6. Basic ZohoHub flow
+
+Once ZohoHub has been configured with your credentials (section 2) and you have a fresh **access
+token**, setup a ZohoHub connection:
+
+```ruby
+ZohoHub.setup_connection access_token: 'ACCESS_TOKEN',
+                         expires_in: 'EXPIRES_IN_SEC',
+                         api_domain: 'API_DOMAIN'
+```
+
+Now you can issue requests to Zoho's API with the Connection object, e.g.:
+
+```ruby
+# request a (paginated) list of all Lead records
+ZohoHub.connection.get 'Leads'
+```
+
+A successful request will receive a response like the sample here: https://www.zoho.com/crm/help/developer/api/get-records.html.
+
+### 7. BaseRecord and record classes
+
+At this point, ZohoHub is starting to do some of the heavy lifting, but using `ZohoHub.connection`
+still gets tedious after just a handful of requests. But we can improve that by allowing ZohoHub
+to build our record classes or by manually defining them ourselves.
+
+#### 7.1 Reflection
+
+TODO
+
+#### 7.2 Subclassing BaseRecord
+
+See `lib/zoho_hub/base_record.rb` and any of the classes in `examples/models/` for reference.
+
+For any Zoho module with which you want to interact via ZohoHub, make a class of the same name that
+inherits from `ZohoHub::BaseRecord`. For example, to build a class for the Leads module:
+
+```ruby
+# lead.rb
+
+class Lead < BaseRecord
+  ...
+end
+```
+
+Specify this module's fields as attributes:
+
+```ruby
+# lead.rb
+
+class Lead < BaseRecord
+  attributes: :id, :first_name, :last_name, :phone, :email, :source, # etc.
+end
+```
+
+Define an `initialize` method to populate attributes:
+
+```ruby
+def initialize(params)
+  attributes.each do |attr|
+    zoho_key = attr_to_zoho_key(attr)
+
+    send("#{attr}=", params[zoho_key] || params[attr] || DEFAULTS[attr])
+  end
+end
+```
+
+Now you can issue requests more easily with your record class, e.g.:
+
+```ruby
+# request a (paginated) list of all Lead records
+Lead.all
+```
+
+## Tips and suggestions
+
+* Using a tool such as Postman or curl to issue HTTP requests and verify responses in isolation
+  can be a great sanity check during setup.
+* Downloading ZohoHub code (as opposed to the gem) and running `bin/console` is a great way to
+  learn how the code works and test aspects of setup and Zoho's API in isolation.
+* [The Zoho API Documentation](https://www.zoho.com/crm/help/developer/api/overview.html) is your
+  friend - especially the sample HTTP requests and responses in the various sections under "Rest
+  API" on the left.
+* If you're manually implementing your record classes (rather than using the reflection mechanism),
+  the files in `/lib/zoho_hub/deprecated_and_only_for_reference_records/` can help you get started.
+* Requests can be issued to Zoho CRM's [Sandbox](https://help.zoho.com/portal/kb/articles/using-sandbox)
+  by configuring `https://crmsandbox.zoho.com/crm` (or regional equivalent) as the `api_domain`.
 
 ## Development
 

data/bin/console

@@ -10,6 +10,8 @@ Dotenv.load
 ZohoHub.configure do |config|
   config.client_id    = ENV['ZOHO_CLIENT_ID']
   config.secret       = ENV['ZOHO_SECRET']
+  config.redirect_uri = ENV['ZOHO_REDIRECT_URI']
+  config.api_domain   = ENV['ZOHO_API_DOMAIN'] if ENV['ZOHO_API_DOMAIN']
   config.debug        = ENV['ZOHO_DEBUG'] || false
 end
 
@@ -18,5 +20,7 @@ puts 'Refreshing token...'
 token_params = ZohoHub::Auth.refresh_token(ENV['ZOHO_REFRESH_TOKEN'])
 ZohoHub.setup_connection(token_params)
 
+self.send(:include, ZohoHub)
+
 require 'pry'
 Pry.start

data/bin/read

@@ -1,10 +1,11 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'bundler/setup'
 require 'zoho_hub'
 require 'zoho_hub/settings/module'
-require 'zoho_hub/records/base_record'
+require 'zoho_hub/base_record'
 
 require 'dotenv'
 Dotenv.load
@@ -12,7 +13,6 @@ Dotenv.load
 ZohoHub.configure do |config|
   config.client_id    = ENV['ZOHO_CLIENT_ID']
   config.secret       = ENV['ZOHO_SECRET']
-  config.redirect_uri = ENV['ZOHO_OAUTH_REDIRECT_URL']
 end
 
 token_params = ZohoHub::Auth.refresh_token(ENV['ZOHO_REFRESH_TOKEN'])
@@ -27,7 +27,9 @@ puts "Found #{modules_hashes.size} modules"
 modules_hashes.each do |hash|
   puts "- Writing configuration for #{hash[:plural_label]}"
 
-  file_name = File.join(ZohoHub.root, 'cache', 'modules', "#{hash[:api_name]}.json")
+  modules_path = File.join(ZohoHub.root, 'cache', 'modules')
+  FileUtils.mkdir_p(modules_path)
+  file_name = File.join(modules_path, "#{hash[:api_name]}.json")
 
   File.open(file_name, 'w') do |file|
     file.write(JSON.pretty_generate(hash))
@@ -36,7 +38,9 @@ modules_hashes.each do |hash|
   next unless hash[:api_supported]
 
   fields_array = ZohoHub::Settings::Field.all_json_for(hash[:api_name])
-  file_name = File.join(ZohoHub.root, 'cache', 'fields', "#{hash[:api_name]}.json")
+  fields_path = File.join(ZohoHub.root, 'cache', 'fields')
+  FileUtils.mkdir_p(fields_path)
+  file_name = File.join(fields_path, "#{hash[:api_name]}.json")
 
   File.open(file_name, 'w') do |file|
     file.write(JSON.pretty_generate(fields_array))

data/bin/zoho_hub

@@ -3,60 +3,41 @@
 
 require 'bundler/setup'
 
-require 'zoho_hub'
-require 'zoho_hub/auth'
-require 'zoho_hub/oauth_callback_server'
-
-require 'launchy'
-require 'optparse'
+begin
+  require 'dotenv'
+  Dotenv.load
+rescue LoadError
+end
 
-default_port = ZohoHub::OauthCallbackServer.settings.port
+require 'zoho_hub/cli/callback_server'
+require 'zoho_hub/cli/read_modules'
 
-options = {}
-parser = OptionParser.new do |op|
-  op.banner = 'Usage: zoho_hub -c CLIENT_ID -s SECRET [options]'
+command = ARGV[0]
 
-  op.on('-c', '--client-id=client_id', 'The Zoho client ID') do |client|
-    options[:client_id] = client
-  end
+def print_commands
+  commands = [
+    ['callback-server', 'run a http server to serve as oauth callback to get a refresh token'],
+    ['read-modules', 'read the configuration from Zoho CRM and save it locally']
+  ]
 
-  op.on('-s', '--secret=secret', 'The Zoho secret') do |secret|
-    options[:secret] = secret
-  end
+  largest_name = commands.map(&:first).max_by(&:length)
+  left_pad = largest_name.length + 5
 
-  op.on('-p', '--port=port', "The port for your callback (default #{default_port})") do |port|
-    options[:port] = port
-  end
-
-  op.on_tail('--version', 'Show version') do
-    puts "ZohoHub #{ZohoHub::VERSION}"
-    exit
+  commands.each do |command|
+    $stdout.print "   #{command.first}".ljust(left_pad)
+    $stdout.puts command.last
   end
 end
 
-parser.parse!
-
-abort(parser.help) if options[:client_id].nil? || options[:secret].nil?
-
-callback_path = ZohoHub::OauthCallbackServer::CALLBACK_PATH
-
-ZohoHub::OauthCallbackServer.set(:port, options[:port]) if options[:port]
-
-bind_port = ZohoHub::OauthCallbackServer.settings.port
-bind_address = ZohoHub::OauthCallbackServer.settings.bind
-
-callback_url = "http://#{bind_address}:#{bind_port}/#{callback_path}"
-
-puts "Callback URL: #{callback_url}"
-
-ZohoHub.configure do |config|
-  config.client_id    = options[:client_id]
-  config.secret       = options[:secret]
-  config.redirect_uri = callback_url
-  config.debug        = true
+case command
+when 'callback-server'
+  ZohoHub::Cli::CallbackServer.new.run(ARGV[1..-1])
+when 'read-modules'
+  ZohoHub::Cli::ReadModules.new.run(ARGV[1..-1])
+else
+  $stdout.puts 'Usage:'
+  $stdout.puts "    zoho_hub [command] [options]\n"
+  $stdout.puts 'where <command> is one of:'
+
+  print_commands
 end
-
-# Open the URL in the browser
-url = ZohoHub::Auth.auth_url
-puts "REQUESTING: #{url}"
-Launchy.open(url)

data/examples/models/campaign.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'zoho_hub/records/base_record'
+
+module ZohoHub
+  # Simple manual Zoho record where we just want to get the name. Something like:
+  # #<ZohoHub::Campaign:0x00007fce2cc22458 @id="78265000003433063", @name="Smith & Williamson">
+  class Campaign < BaseRecord
+    attributes :id, :name
+
+    attribute_translation name: :Campaign_Name
+  end
+end

data/{lib/zoho_hub/deprecated_and_only_for_reference_records → examples/models}/potential.rb

@@ -10,6 +10,7 @@ module ZohoHub
     attributes :review_outcome, :first_created, :last_modified, :preferred_term, :project_notes
     attributes :campaign_id, :account_id, :contact_id, :campaign_detail, :reviewers_comment
 
+    # List of default values for some of the attributes, used in the initializer.
     DEFAULTS = {
       currency: 'GBP',
       territory: 'UK all',
@@ -26,7 +27,7 @@ module ZohoHub
       use_proceeds: :use_proceeds
     )
 
-    def initialize(params)
+    def initialize(params = {})
       attributes.each do |attr|
         zoho_key = attr_to_zoho_key(attr)
 

data/{lib/zoho_hub/deprecated_and_only_for_reference_records → examples/models}/quote.rb

@@ -4,21 +4,17 @@ require 'zoho_hub/records/base_record'
 
 module ZohoHub
   class Quote < BaseRecord
-    attributes :id, :stage, :subject
-    attributes :potential_id
+    attributes :id, :stage, :subject, :potential_id
 
+    # The translation from attribute name to the JSON field on Zoho. The default behaviour will be
+    # to Camel_Case the attribute so on this list we should only have exceptions to this rule.
     attribute_translation(
       id: :id,
       stage: :Quote_Stage
     )
 
-    def initialize(params)
-      puts Rainbow(params).bright.red
-      attributes.each do |attr|
-        zoho_key = attr_to_zoho_key(attr)
-
-        send("#{attr}=", params[zoho_key] || params[attr])
-      end
+    def initialize(params = {})
+      super
 
       @potential_id ||= params.dig(:Deal_Name, :id)
       @lender_organisation_id ||= params.dig(:Account_Name, :id)

data/lib/zoho_hub/auth.rb

@@ -12,6 +12,7 @@ module ZohoHub
     extend Forwardable
 
     TOKEN_PATH = '/oauth/v2/token'
+    REVOKE_TOKEN_PATH = '/oauth/v2/token/revoke'
     AUTH_PATH = '/oauth/v2/auth'
 
     DEFAULT_SCOPES = %w[
@@ -31,14 +32,6 @@ module ZohoHub
       @scopes = scopes
     end
 
-    def token_full_uri
-      Addressable::URI.join(api_domain, TOKEN_PATH)
-    end
-
-    def auth_full_uri
-      Addressable::URI.join(api_domain, AUTH_PATH)
-    end
-
     def self.auth_url(access_type: DEFAULT_ACCESS_TYPE, scopes: DEFAULT_SCOPES)
       new(access_type: access_type, scopes: scopes).auth_url
     end
@@ -46,7 +39,7 @@ module ZohoHub
     def auth_url
       uri = auth_full_uri
 
-      uri.query_values = {
+      query = {
         client_id: client_id,
         scope: @scopes.join(','),
         access_type: @access_type,
@@ -54,21 +47,27 @@ module ZohoHub
         response_type: 'code'
       }
 
+      # The consent page must be presented otherwise we don't get the refresh token back.
+      query[:prompt] = 'consent' if @access_type == DEFAULT_ACCESS_TYPE
+
+      uri.query_values = query
+
       Addressable::URI.unencode(uri.to_s)
     end
 
-    def token_url(grant_token)
-      uri = token_full_uri
+    def auth_full_uri
+      Addressable::URI.join(api_domain, AUTH_PATH)
+    end
 
-      uri.query_values = {
-        client_id: client_id,
-        client_secret: secret,
-        code: grant_token,
-        redirect_uri: redirect_uri,
-        grant_type: 'authorization_code'
-      }
+    def self.refresh_token(refresh_token)
+      new.refresh_token(refresh_token)
+    end
 
-      Addressable::URI.unencode(uri.to_s)
+    def refresh_token(refresh_token)
+      result = Faraday.post(refresh_url(refresh_token))
+
+      json = parse(result.body)
+      json.merge(refresh_token: refresh_token)
     end
 
     def refresh_url(refresh_token)
@@ -84,15 +83,8 @@ module ZohoHub
       Addressable::URI.unencode(uri.to_s)
     end
 
-    def self.refresh_token(refresh_token)
-      new.refresh_token(refresh_token)
-    end
-
-    def refresh_token(refresh_token)
-      result = Faraday.post(refresh_url(refresh_token))
-
-      json = parse(result.body)
-      json.merge(refresh_token: refresh_token)
+    def token_full_uri
+      Addressable::URI.join(api_domain, TOKEN_PATH)
     end
 
     def revoke_refresh_token(refresh_token)
@@ -117,6 +109,22 @@ module ZohoHub
       parse(result.body)
     end
 
+    def token_url(grant_token)
+      uri = token_full_uri
+
+      uri.query_values = {
+        client_id: client_id,
+        client_secret: secret,
+        code: grant_token,
+        redirect_uri: redirect_uri,
+        grant_type: 'authorization_code'
+      }
+
+      Addressable::URI.unencode(uri.to_s)
+    end
+
+    private
+
     def parse(body)
       MultiJson.load(body, symbolize_keys: true)
     end

data/lib/zoho_hub/base_record.rb

@@ -3,12 +3,14 @@
 require 'zoho_hub/response'
 require 'zoho_hub/with_connection'
 require 'zoho_hub/with_attributes'
+require 'zoho_hub/with_validations'
 require 'zoho_hub/string_utils'
 
 module ZohoHub
   class BaseRecord
     include WithConnection
     include WithAttributes
+    include WithValidations
 
     # Default nnumber of records when fetching all.
     DEFAULT_RECORDS_PER_PAGE = 200
@@ -34,16 +36,18 @@ module ZohoHub
           raise RecordNotFound, "Couldn't find #{request_path.singularize} with 'id'=#{id}"
         end
 
-        new(response.data)
+        new(response.data.first)
       end
 
       def where(params)
         path = File.join(request_path, 'search')
 
-        response = get(path, params)
-        data = response[:data]
+        body = get(path, params)
+        response = build_response(body)
+
+        data = response.nil? ? [] : response.data
 
-        data.map { |info| new(info) }
+        data.map { |json| new(json) }
       end
 
       def find_by(params)
@@ -55,12 +59,12 @@ module ZohoHub
         new(params).save
       end
 
-      def all(options = {})
-        options[:page] ||= DEFAULT_PAGE
-        options[:per_page] ||= DEFAULT_RECORDS_PER_PAGE
-        options[:per_page] = MIN_RECORDS if options[:per_page] < MIN_RECORDS
+      def all(params = {})
+        params[:page] ||= DEFAULT_PAGE
+        params[:per_page] ||= DEFAULT_RECORDS_PER_PAGE
+        params[:per_page] = MIN_RECORDS if params[:per_page] < MIN_RECORDS
 
-        body = get(request_path, options)
+        body = get(request_path, params)
         response = build_response(body)
 
         data = response.nil? ? [] : response.data
@@ -86,17 +90,24 @@ module ZohoHub
       end
     end
 
+    def initialize(params = {})
+      attributes.each do |attr|
+        zoho_key = attr_to_zoho_key(attr)
+
+        send("#{attr}=", params[zoho_key] || params[attr])
+      end
+    end
+
     def save
       body = if new_record? # create new record
                post(self.class.request_path, data: [to_params])
              else # update existing record
-               path = File.join(self.class.request_path, id)
-               put(path, data: [to_params])
+               put(File.join(self.class.request_path, id), data: [to_params])
              end
 
       response = build_response(body)
 
-      response.data.dig(:details, :id)
+      response.data.first.dig(:details, :id)
     end
 
     def new_record?