There are many cases where inquiries and contact forms are configured and managed on a company's website. This article introduces how to manage these inquiries using the Kintone REST API client for Ruby and an inquiry form on a website created with Ruby on Rails. Use the kintone_rb SDK by SonicGarden for this tutorial.

Note

The SDK introduced in this article is a 3rd party SDK. Check the licenses, functions, etc. before using.

This tutorial uses the following tools:

• Rails Development Environment (For those new to Rails, refer to Getting Started with Rails to set up an environment)
• Ruby 2.7.0 or later (This article uses Ruby 2.7.5, Rails 7.0.2.)
• A Kintone account with the Help Desk Management App

Log into Kintone and add the Help Desk Management App from the Kintone Marketplace. Refer to Adding a Sample App from the Kintone Help for more details.

Navigate to the Help Desk Management App and click the Change app settings icon (gear icon) to access the App settings.

Add a Text field to the form for the Company name. Then update the field title and field code for each field in the form to match the table below. Save the form when finished.

Next, open the App Settings tab and click API Token under Customization and Integration.

Click the Generate button and check Add records. Then save the settings.
Make a note of the generated API token, as it will be necessary later for the customization code. Also make a note the App ID (in the following sample application, the App ID is 272).

Finally, to apply the App settings, click the Update App button.

Settings for the Help Desk Management App are now complete.

Next, make an inquiry form application with Ruby on Rails.
(For those without a development environment for Ruby on Rails, refer to Getting Started with Rails to set up an environment.)

Open the terminal and execute the following command.

1

$ rails new contact

This creates a Rails application called contact.
As the subsequent commands are executed in the created contact directory, move to the directory with the following command.

1

$ cd contact

Before creating the form, install the kintone_rb SDK .

Open Gemfile and add the following command.

1

gem 'kintone_rb'

After saving the file, execute the following command.

1

$ bundle install

Create a controller with the following command. As an example, the controller is named inquiries.

1

$ rails generate controller inquiries

Open the routes.rb file in the config folder.

Edit it to match the following code.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

=begin
RoR Route Config Sample
Copyright (c) 2022 Cybozu
Licensed under the MIT License
=end

Rails.application.routes.draw do
  get '/inquiries', to: 'inquiries#new'
  post '/inquiries', to: 'inquiries#create'
  resources :inquiries

  root 'inquiries#new'
end

Create a new.html.erb file in the inquiries folder under the views folder.

Using the following code in the newly created new.html.erb file, create an inquiry form by using FormBuilder.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

<%#
# RoR Webform View Sample
# Copyright (c) 2022 Cybozu
# Licensed under the MIT License
%>

<h1>Inquiry</h1>
<%= form_for :inquiry, url: inquiries_path do |form| %>
  <p>
    <%= form.label :company_name, "Company:" %><br>
    <%= form.text_field :company_name %>
  </p>
  <p>
    <%= form.label :client_name, "Name:" %><br>
    <%= form.text_field :client_name %>
  </p>
  <p>
    <%= form.label :contact_type, "Inquiry Type:" %><br>
    <table style="border: 1px solid black;">
      <tr>
        <td>
    <%= form.radio_button :contact_type, "Sales Inquiry"%>
    <%= form.label :product, "Sales Inquiry" %>
    <%= form.radio_button :contact_type, "Support"%>
    <%= form.label :order, "Support" %>
    <%= form.radio_button :contact_type, "Partnertship"%>
    <%= form.label :claim, "Partnertship" %>
    <%= form.radio_button :contact_type, "Other"%>
    <%= form.label :misc, "Other" %>
        </td>
      </tr>
    </table>
  </p>
  <p>
    <%= form.label :details, "Details:" %><br>
    <%= form.text_area :details, size: "50x6" %>
  </p>

  <p>
    <%= form.submit "Send" %>
  </p>
<% end  %>

The following form should be generated.

Generate a model of the resource name specified earlier.
Run the following command to generate the inquiry model.

1

$ rails generate model Inquiry company_name:string client_name:string contact_type:string details:text

This generates the following model.

Execute migration with the following command to create a table in the database.

1

$ rails db:migrate

An Inquiries table is now created in the database.
In this case, the default database sqlite 3 was used. If sqlite 3 has not been installed yet, execute the following command to install it.

1

$ gem install sqlite3

Edit the controller created earlier.
Open inquiries_controller.rb in the controllers folder with an editor.

Type the following code into the inquiries_controller.rb file. Replace the {subdomain}, {API Token}, and {App ID} in lines 17 and 18 with the name of the Kintone subdomain, the API token of the App, and the App ID.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

=begin
RoR Controller Sample
Copyright (c) 2022 Cybozu
Licensed under the MIT License
=end

require 'kintone_rb'
class InquiriesController < ApplicationController

  def new
  end

  def create
    @inquiry = Inquiry.new(inquiry_params)
    if @inquiry.save
      # Use token authentication
      api = Kintone::Api.new("{subdomain}.kintone.com", "{API Token}")
      app = {App ID}

      # Record register(single record)
      # Use Hash
      record = {"Company" => {"value" => inquiry_params[:company_name]},
                "Customer_name" => {"value" => inquiry_params[:client_name]},
                "QType" => {"value" => inquiry_params[:contact_type]},
                "Detail" => {"value" => inquiry_params[:details]}
                }
      api.record.register(app, record)
      redirect_to root_path
    else
      render 'new'
    end
  end

  private
    def inquiry_params
      params.require(:inquiry).permit(:company_name, :client_name, :contact_type, :details)
    end
end

The routing within the above code is defined as follows to create the inquiry form.

The resource name specifies the inquiries created earlier.

1

resources :inquiries

The code also sets a form for creating an inquiry on the homepage.

1

root 'inquiries#new'

For the sake of simplicity, only the new and create actions of the controller are defined.
The inquiry form is displayed with the new method (as there is no processing in particular, the method is blank) and the input data is saved with the create method.

1
2

def new
end

After saving the form data in the database, the data is registered into the Kintone App.

1
2
3

if @inquiry.save
  ...
end

The following code loads the kintone_rb and creates an instance.
Specify the sub-domain name, the API token, and the App ID noted in the Generate an API Token section (refer to the README for more details).

1
2
3
4

require 'kintone_rb'
# Use token authentication
  api = Kintone::Api.new("{subdomain}.kintone.com", "{API Token}")
  app = {App ID}

The record data is set using Hashes, and is registered into the Kintone App via REST API.

1
2
3
4
5
6
7
8

# Record register(single record)
# Use Hash
record = {"Company" => {"value" => inquiry_params[:company_name]},
          "Customer_name" => {"value" => inquiry_params[:client_name]},
          "QType" => {"value" => inquiry_params[:contact_type]},
          "Detail" => {"value" => inquiry_params[:details]}
          }
api.record.register(app, record)

Start the local Rails server with the following command.

1

$ rails server

Accessing http://localhost:3000 through the browser will display the following inquiry form.
Enter in data and click the Send button to add a new record to Kintone.

• Getting Started with Rails
• kintone_rb