Community blogs are written by members of the SS&C Blue Prism Community and represent the views of the author. For more information on Community Blogs, or to submit your own, see here.
Note that this article was originally written in Japenese. For the English language translation, click the link below.
Japanese version
やりたいこと
Blue Prismのプロセスから会議設定をしたい。
設定したあとにほしいものは、設定した会議のURLとパスコード。
手でやるときはこの画面でやります。
どうやるのか
公式のこのページ「Zoom APIの使用」の図が一発でわかるので転載します。
- BPプロセスからZoom認証サーバへ、認証のリクエストを投げる
- アクセストークンが返ってくる
- そのトークンを使って、Zoom APIに、会議作成のリクエストを投げる
- 会議が作成されて、会議の情報が返ってくる
まずアプリを作成する
Zoom App Marketplace に行って、Server-to-Server-OAuth のアプリを用意します。
Zoomのアカウントは無料のやつでも会社のでもとりあえずオッケー。そのアカウントで会議を作成します。
サインインしたら右上のメニューから、Develop→Build Server-to-Server Appを選択。
そんなにいろいろ設定するところはないのですぐできます。公開はしないでアクティベートだけしたらいいです。
アプリを作成したら、認証情報（アカウントID、クライアントID、クライアントシークレット）をメモっておきます。
Blue Prismで認証情報を作成する
クライアントID、クライアントシークレットを、OAuthクライアント認証で作成します。
認証情報取得アクションを作成する
認証情報を取得するのはいつものアレ。
この認証情報を投げてトークンを取得するのですが、投げる前にBase64エンコードする必要があります。
エンコードのVBOはDXにあります。 Utility - Encode Decode
アクションの中身はこうです。
変換するテキストの中身はこんな感じです。これをエンコードのステージの入力にします。
出力引数は、「クライアントID:クライアントシークレット」をBase64エンコードしたテキストです。
ークン生成アクションを作成する
中身はこうです。
入力引数は
- アカウントID：アプリを作成したときにメモったやつ
- 認証情報取得アクションの出力引数であるテキスト（クライアントID:クライアントシークレット）
出力引数は生成したトークンが入っているコレクションです。
生JSONだと扱いにくいので、コレクションに変換してから返します。Utility - JSONは標準VBOです。
Utility - HTTPも標準VBO。これのPostアクションを使います。中身はこう。
投げるヘッダがBasicなので、Use Bearer TokenはFalseにしておきます。
URLは「https://zoom.us/oauth/token?grant_type=account_credentials&account_id={アカウントID}」
HeadersはAuthorizationの1行だけ。設定する値は「Basic Base64エンコードしたテキスト」です。
会議を作成する
材料は揃ったので、会議を作成します。
先述の認証情報取得やトークン生成のアクションは公開せず、このアクションだけ公開にしておきます。
入力引数は
- アカウントID
- 認証情報名
- 会議タイトル：テキスト
- 開始日時：日時
- 所要時間（分）：数値
アクションの中身はこんな感じ。
認証情報取得→トークン生成→開始日時をテキストに変換→リクエストを投げる
開始日時をテキストに変換するときの形は「yyyy-MM-ddTHH: mm:ss」。日と時の間に「T」が入ります。
Post JSONステージの中身はこう。
Bearer Tokenに、トークン生成アクションの出力で受け取ったトークンを設定し、Use Bearer TokenをTrueにします。
Bodyの中身。各値を入力引数の値にReplaceします。
{
"topic": "<会議タイトル>",
"start_time": "<開始日時>",
"duration": <所要時間>,
"timezone": "Asia/Tokyo"
}
返ってきたJSONをコレクションに変換して、会議URLとパスコードを返します。
コレクションの項目で使いそうなのは以下。
- start_url：ホストとして参加するときのURL
- join_url：普通の参加者にお知らせするURLはこっち
- password：パスコード。これは半角英数で、「H323_password」「pstn_password」のほうは数字です。H323とかpstnって何やねんというかたは、私も知識が薄くて上手に説明できないので、VoIPの説明とかをググってください。
これらを使って会議設定のプロセスを作成し、会議設定したあとに参加者にメールを送信するとかの処理を追加したらいいと思います。
終わりです
今回はタイトルと時間だけで設定しましたが、手で設定するときの項目はだいたい全部設定できます。
BodyのJSONに書くときの項目など、詳しくは公式資料を参照してください。→ Zoom API の概要
English version
Automating Zoom Meeting Creation with SS&C Blue Prism
This blog post outlines how to automate the creation of Zoom meetings directly from a Blue Prism process, detailing the steps from setting up the Zoom API integration to generating meeting links and passcodes.
The objective
My primary goal is to automate the scheduling of Zoom meetings directly from a Blue Prism (BP) process. Once a meeting is successfully set up, I need to retrieve its essential details: the meeting URL and the passcode.
When performing this task manually, I typically use the standard Zoom meeting scheduling interface. The aim here is to replicate and automate this functionality programmatically.
Methodology
The official Zoom API documentation provides a clear and concise diagram illustrating the process for "Using the Zoom API." I'll reference it here as it's easy to grasp at a glance:
- Send an authentication request from the BP process to the Zoom authentication server. This initial step is crucial for verifying that our Blue Prism process is authorized to interact with the Zoom API.
- An access token is returned. This token acts as a temporary key, granting our process permission to make subsequent API calls.
- Using that token, send a request to create a meeting to the Zoom API. With the access token, we can now instruct Zoom to create a meeting with our specified parameters.
- The meeting is created, and the meeting information is returned. Upon successful creation, the Zoom API sends back all the relevant details of the newly scheduled meeting, including the URL and passcode we need.
Creating an app in Zoom
To begin, we need to set up an application within the Zoom ecosystem.
Navigate to the Zoom App Marketplace and prepare a Server-to-Server OAuth app. This type of app is ideal for server-side integrations where there's no user interface for authorization, making it perfect for a Blue Prism automation.
A free Zoom account or a company account will suffice for this setup. Importantly, any meetings created through this integration will be associated with the account used to create the app.
After signing in, select Develop → Build Server-to-Server App from the top-right menu.
The configuration settings for this app are minimal, allowing for a quick setup. Simply activate the app without publishing it to the public marketplace, as it's for internal use.
Once the app is created, make sure to securely note down the generated credentials: the Account ID, Client ID, and Client Secret. These are vital for authenticating your Blue Prism process with Zoom.
Create Credentials in Blue Prism
Next, we'll configure Blue Prism to securely store and manage these Zoom API credentials.
Create a new credential in Blue Prism to store the Client ID and Client Secret using OAuth client authentication. This method is standard for authenticating with APIs that use the OAuth 2.0 framework, where the client application (Blue Prism in this case) identifies itself using these two keys.
Create an Action to Get Credentials
In Blue Prism, we'll create a reusable action to retrieve these credentials.
Getting credentials is a standard action performed using Blue Prism's internal VBO (Visual Business Object). This refers to a pre-built, core component within Blue Prism that handles common tasks.
The credential information (specifically, the "Client ID:Client Secret" string) needs to be Base64 encoded before being sent to the Zoom authentication server. This encoding is a common practice for transmitting binary data or sensitive text over HTTP, ensuring it's not corrupted and is handled correctly.
The VBO for encoding can be found in the DX: Utility - Encode Decode library, which provides actions for various encoding and decoding operations.
The actions and steps within the Blue Prism process would look something like this:
The content of the text to be converted (i.e., the input for the encoding stage) is simply the concatenation of your Client ID and Client Secret, separated by a colon: Client ID:Client Secret.
The output parameter of this encoding stage will be the Base64 encoded string of Client ID:Client Secret.
Create an Action to Generate a Token
Now, we'll build the action that uses the encoded credentials to obtain an access token from Zoom.
The steps for this action are illustrated in the figure below:
The input parameters for this action are:
- Account ID: The Account ID you noted when creating the Zoom app.
- Encoded Client ID:Client Secret: The Base64 encoded text value obtained from the output parameter of the 'Get Credentials' action.
The output parameter of this action will be a collection containing the generated access token and other token-related information.
Since the raw JSON response from the API is hard to work with directly in Blue Prism, we'll convert it into a collection. The Utility - JSON VBO is a standard Blue Prism component designed for parsing and manipulating JSON data.
The Utility - HTTP VBO is also a standard Blue Prism component, used for making HTTP requests. We will use its Post action to send the authentication request. The configuration for this Post action is as follows:
- Since the header to be sent is 'Basic' authentication, set 'Use Bearer Token' to False for this specific request. Bearer tokens are used in subsequent API calls after authentication.
- The URL for the token request is: https://zoom.us/oauth/token?grant_type=account_credentials&account_id={Account ID}. The grant_type=account_credentials parameter specifies the OAuth flow we are using, which is based on the app's credentials.
- The Headers parameter will contain just one line for Authorization. The value to set is Basic <Base64 encoded text>, where <Base64 encoded text> is the output from the 'Get Credentials' action.
Create a Meeting
With the access token in hand, we have all the "ingredients" to create a Zoom meeting.
It's good practice to only publish this 'Create Meeting' action for external use in your Blue Prism processes, keeping the 'Get Credentials' and 'Generate Token' actions as internal, helper components. This promotes modularity and security.
The input parameters for this 'Create Meeting' action are:
- Account ID: The Zoom Account ID.
- Credential Name: The name of the Blue Prism credential storing your Client ID and Client Secret.
- Meeting Title: A text field for the subject of the meeting.
- Start Date/Time: A DateTime field indicating when the meeting will begin.
- Duration (minutes): A Number field specifying the meeting's length.
The action's content flow would look something like this:
The flow involves: Get Credentials → Generate Token → Convert Start Date/Time to Text → Send Request.
The format for converting the start date/time to text is crucial for the Zoom API: yyyy-MM-ddTHH:mm:ss. Note that a 'T' is inserted between the date and time components, conforming to the ISO 8601 standard.
The content of the Post JSON stage (which sends the meeting creation request) is configured as follows:
- Set the token received from the output of the 'generate token' action to the Bearer Token field, and set 'Use Bearer Token' to True. This tells the HTTP request to use the access token for authorization.
The Body content of the JSON request is as follows. Each placeholder value should be replaced with the corresponding input parameter's value:
{
"topic": "<Meeting Title>",
"start_time": "<Start Date/Time>",
"duration": <Duration>,
"timezone": "Asia/Tokyo"
}
After the meeting is created, the Zoom API returns a JSON response. We'll convert this returned JSON into a Blue Prism collection to easily extract the necessary meeting URL and passcode. The following are common and useful collection items you'll likely want to retrieve:
- start_url: This is the URL for the host to start the meeting.
- join_url: This is the URL that participants will use to join the meeting. This is the one you'll typically share.
- password: This is the alphanumeric passcode for the meeting. You might also see H323_password and pstn_password, which are numeric passcodes. For those curious about H323 or PSTN, these refer to different communication protocols (H.323 for video conferencing over IP networks and PSTN for Public Switched Telephone Network, i.e., traditional phone lines). I don't have enough knowledge to explain them in depth here, so please use a search engine to find explanations related to VoIP (Voice over Internet Protocol) and teleconferencing standards.
I believe it would be beneficial to extend this meeting setup process by adding subsequent steps, such as sending email invitations to participants with the join_url and password after the meeting has been successfully created.
That's all for this guide!
This time, I've only covered setting up a meeting with a title, start time, and duration. However, the Zoom API is highly flexible, and almost all options that can be configured manually through the Zoom interface (e.g., alternative hosts, waiting rooms, recording settings) can also be configured programmatically by adding relevant fields to the Body JSON.
For a comprehensive list of all possible parameters and their details, please refer to the official Zoom API documentation, specifically the "Zoom API Overview" section.
