kintone-client.record — toyokumo/kintone-client 0.6.0

add-all-records clj/s

(add-all-records conn app records)

Add Multiple Records to an app.

This API can add more than 100 records unlike add-records.

If the request fail, this will stop executing and return the response that includes both of completed and failed values.

app - The kintone app ID. integer.

records - The sequence of record data that you want to add to kintone app. See API reference regarding record format.

add-comment clj/s

(add-comment conn app id {:as comment :keys [text mentions]})

Add a comment to a record in an app.

app - The kintone app ID. integer

id - The record id. integer

comment - A map including comment details.

:text - The comment text. The maximum characters of the comment is 65535.

:mentions - A sequence including information to mention other users.

:code - The code the user, group or organization that will be mentioned.
        The maximum number of mentions is 10.
        The mentioned users will be placed in front of the comment text when the API succeeds.

:type - The type of the mentioned target.
        USER or GROUP or ORGANIZATION

add-record clj/s

(add-record app record)

(add-record conn app record)

Add one record to an app.

app - The kintone app ID. integer

record - The record data that you want to add to kintone app. See API reference regarding record format.

add-records clj/s

(add-records app records)

(add-records conn app records)

CAUTION: Consider using add-all-records first. Use this only if add-all-records takes too many records to eat up the whole RAM of the machine.

Add multiple records to an app.

app - The kintone app ID. integer

records - The sequence of record data that you want to add to kintone app. The size of records must be 100 or less. See API reference regarding record format. If the request fail, all registration will be canceled.

bulk-request clj/s

(bulk-request conn requests)

Runs multiple API requests to multiple apps in one go.

requests - The multiple request maps. Its size must be 20 or less. The following functions return a request map which is used here when you does not pass the connection map to these. - add-record - add-records - update-record - update-records - delete-records - delete-records-with-revision - update-record-status - update-records-status

create-cursor clj/s

(create-cursor conn app)

(create-cursor conn app {:keys [fields query size]})

CAUTION: Consider using get-all-records first (saves you from forgetting to delete cursor). Use this only if get-all-records returns too many records to eat up the whole RAM of your machine.

Create a cursor that is used to retrieve records.

app - The kintone app ID. integer

opts

:fields - Sequence of field codes you want in the response. sequence of string or nil

:query - The kintone query. It can't have limit or offset. string or nil

:size - Number of records to retrieve per request. integer or nil Default: 100. Maximum: 500

delete-all-records-by-query clj/s

(delete-all-records-by-query conn app query)

Deletes all records in an app by query string. Can delete over 2000 records, but can't do rollback.

app - The kintone app ID. integer

query - The kintone query. It can't have limit or offset. string

delete-comment clj/s

(delete-comment conn app id comment-id)

Delete a comment in a record in an app

app - The kintone app ID. integer

id - The record id. integer

comment-id - The comment id. integer

delete-cursor clj/s

(delete-cursor conn {:as cursor :keys [id]})

CAUTION: Consider using get-all-records first (saves you from forgetting to delete cursor). Use this only if get-all-records returns too many records to eat up the whole RAM of your machine.

Delete a cursor.

cursor - The kintone record cursor A map has cursor id

delete-records clj/s

(delete-records app ids)

(delete-records conn app ids)

Deletes multiple records in an app.

app - The kintone app ID. integer

ids - Sequence of record id that you want to delete. The size of records must be 100 or less. sequence of integer

delete-records-with-revision clj/s

(delete-records-with-revision app params)

(delete-records-with-revision conn app params)

Deletes multiple records in an app.

app - The kintone app ID. integer

params - params includes following keys. The size of params must be 100 or less. sequence of map

:id - record id that you want to delete. integer

:revision - The revision number of the record. integer

file-download clj/s≠

clj

(file-download conn file-key)

(file-download conn file-key as)

cljs

(file-download conn file-key)

Download a file from an attachment field in an app.

file-key - The value(string) is set on the attachment field in the response that is gotten from GET record APIs. So the file-key is different from that obtained from the response when using the Upload File API.

as - (Only Clojure) A keyword that is used for output coercion. default :byte-array See clj-http document for detail.

file-upload clj/s≠

clj

(file-upload conn file)

cljs

(file-upload conn file filename)

Uploads a file to kintone.

When a file is uploaded, it produces a file key. Note that although this API uploads a file to kintone, it does not upload the file to an attachment field of an App. To upload the file to an Attachment field, the file key is used with the Add Record or Update Record API.

file - (Clojure) File (ClojureScript) File object

filename - The filename you want to set to string, Only for ClojureScript

get-all-records clj/s

(get-all-records conn app)

(get-all-records conn app {:as opts :keys [fields query size]})

Get all records with cursor.

The cursor is released when all records are fetched.

app - The kintone app ID. integer

opts

:fields - Sequence of field codes you want in the response. sequence of string or nil

:query - The kintone query. It can't have limit or offset. string or nil

:size - Number of records to retrieve per request. integer or nil Default: 100. Maximum: 500

get-comments clj/s

(get-comments conn app id)

(get-comments conn app id {:as opts :keys [order offset limit]})

Retrieves multiple comments from a record in an app.

app - The kintone app ID. integer

id - The record id. integer

opts

:order - The sort order of the Comment ID. Specifying "asc" will sort the comments in ascending order, and "desc" will sort the comments in descending order.

:offset - This skips the retrieval of the first number of comments. If it is 30, response skips the first 30 comments, and retrieves from the 31st comment. There is no maximum for this value.

:limit - The number of records to retrieve. If it is 5, response retrieve the first 5 comments. The default and maximum is 10 comments.

get-record clj/s

(get-record conn app id)

Retrieves details of 1 record from an app.

app - The kintone app ID. integer id - The record ID in kintone app. integer

get-records-by-cursor clj/s

(get-records-by-cursor conn {:as cursor :keys [id]})

CAUTION: Consider using get-all-records first (saves you from forgetting to delete cursor). Use this only if get-all-records returns too many records to eat up the whole RAM of your machine.

Get one block of records with cursor.

:id - Cursor id string

get-records-by-query clj/s

(get-records-by-query conn app)

(get-records-by-query conn app {:keys [fields query]})

Retrieves details of multiple records from an app using a query string.

app - The kintone app ID. integer

opts

:fields - Sequence of field codes you want in the response. sequence of string or nil

:query - The kintone query. string or nil

A response map always contains the totalCount of query-matched records.

update-all-records clj/s

(update-all-records conn app records)

Updates details of multiple records in an app, by specifying their record id, or a different unique keys. This API can update more than 100 records unlike update-records. If the request fail, this will stop executing and return the response that includes both of completed and failed values.

app - The kintone app ID. integer

records - The record data that you want to update. See API reference regarding record format. If the request fail, all updating will be canceled.

update-record clj/s

(update-record app {:as params :keys [id update-key record revision]})

(update-record conn app {:as params :keys [id update-key record revision]})

Updates a record. There must be :id or :update-key in the params.

app - The kintone app ID. integer

params - A map of update request params.

:id - The record ID of the kintone app. If :id is none or nil, :update-key is necessary. integer

:update-key - The unique key of the record to be updated. If :update-key is none or nil, :id is necessary. string

:record - The record data that you want to update. See API reference regarding record format.

:revision - The revision number of the record. integer, optional

update-record-assignees clj/s

(update-record-assignees conn app id assignees revision)

Update assignees of a record.

app - The kintone app ID. integer

id - The record id. integer

assignees - The user codes of the assignees. If empty, no users will be assigned. The maximum number of assignees is 100. sequence of string

revision - The revision number of the record. integer, optional

update-record-status clj/s

(update-record-status app {:as params :keys [id action assignee revision]})

(update-record-status conn app {:as params :keys [id action assignee revision]})

Updates the Status of a record of an app.

app - The kintone app ID. integer

params

:id - The record id. integer

:action - The Action name of the action you want to run. If the localization feature has been used to apply multiple translations of the action, specify the name of the action in the language settings of the user that will run the API. Note "Action name" refers to the text on the button that is pressed to move Process Management on to the next status.

:assignee - The user code of the assignee. If empty, no users will be assigned. The maximum number of assignees is 100. sequence of string

:revision - The revision number of the record. integer, optional

update-records clj/s

(update-records app records)

(update-records conn app records)

CAUTION: Consider using update-all-records first. Use this only if update-all-records takes too many records to eat up the whole RAM of the machine.

Updates details of multiple records in an app, by specifying their record id, or a different unique key.

app - The kintone app ID. integer

records - The record data that you want to update. See API reference regarding record format. The size of records must be 100 or less. If the request fail, all updating will be canceled. Each record must be following map.

:id - The record ID of the kintone app.
      If :id is none or nil, :update-key is necessary.
      integer

:update-key - The unique key of the record to be updated.
              If :update-key is none or nil, :id is necessary.
              string

:record - The record data that you want to update.
          See API reference regarding record format.

:revision - The revision number of the record.
            integer, optional

update-records-status clj/s

(update-records-status app [{:keys [id action assignee revision]} :as records])

(update-records-status conn
                       app
                       [{:keys [id action assignee revision]} :as records])

Updates the Status of multiple records of an app.

app - The kintone app ID. integer

records - sequence of map. each map has following keys. The size must be 100 or less.

:id - The record id. integer

:action - The Action name of the action you want to run. If the localization feature has been used to apply multiple translations of the action, specify the name of the action in the language settings of the user that will run the API. Note "Action name" refers to the text on the button that is pressed to move Process Management on to the next status.

:assignee - The user code of the assignee. If empty, no users will be assigned. The maximum number of assignees is 100. sequence of string

:revision - The revision number of the record. integer, optional