GS2-Schedule SDK API リファレンス

各種プログラミング言語向け GS2-SDK の モデルの仕様 と API のリファレンス

モデル

Namespace

ネームスペース

ネームスペースは一つのプロジェクトで同じサービスを異なる用途で複数利用できるようにするための仕組みです。
GS2 のサービスは基本的にネームスペースというレイヤーがあり、ネームスペースが異なれば同じサービスでもまったく別のデータ空間として取り扱われます。

そのため、各サービスの利用を開始するにあたってネームスペースを作成する必要があります。

有効化条件必須デフォルト値の制限説明
namespaceIdstring
~ 1024文字ネームスペースGRN
namestring
~ 128文字ネームスペース名
descriptionstring~ 1024文字説明文
logSettingLogSettingログの出力設定
createdAtlong
現在時刻作成日時 (UNIX時間 単位:ミリ秒)
updatedAtlong
現在時刻最終更新日時 (UNIX時間 単位:ミリ秒)
revisionlong0~ 9223372036854775805リビジョン

関連するメソッド

describeNamespaces createNamespace getNamespace updateNamespace deleteNamespace


EventMaster

イベントマスター

イベントの期間は絶対期間と相対期間の2種類存在します。
絶対期間は 2021年1月1日 00:00(UTC) ~ 2021年1月7日 23:59(UTC) のような固定の期間で、
相対期間は トリガーを引いたタイミングから 24時間 のようなゲームプレイヤー毎に異なる期間をイベント期間とするものです。

イベントには開催期間だけでなく、繰り返しが設定できるようになっており
イベント期間のうち、月曜日の 10:00 ~ 11:00 だけをイベント期間とするような設定も可能です。

有効化条件必須デフォルト値の制限説明
eventIdstring
~ 1024文字イベントマスターGRN
namestring
~ 128文字イベントの種類名
descriptionstring~ 1024文字説明文
metadatastring~ 2048文字メタデータ
scheduleTypeenum {
  “absolute”,
  “relative”
}
~ 128文字イベント期間の種類
scheduleType に指定する列挙型の定義
absoluteBeginlongイベントの開始日時 (UNIX時間 単位:ミリ秒)
absoluteEndlongイベントの終了日時 (UNIX時間 単位:ミリ秒)
relativeTriggerNamestring{scheduleType} == “relative”
~ 128文字イベントのトリガー名
scheduleType が “relative” であれば 必須
repeatSettingRepeatSetting
繰り返し設定
createdAtlong
現在時刻作成日時 (UNIX時間 単位:ミリ秒)
updatedAtlong
現在時刻最終更新日時 (UNIX時間 単位:ミリ秒)
revisionlong0~ 9223372036854775805リビジョン

scheduleType に指定する列挙型の定義

定義説明
absolute固定期間
relativeプレイヤー別期間

関連するメソッド

describeEventMasters createEventMaster getEventMaster updateEventMaster deleteEventMaster


Trigger

トリガー

トリガーはゲームプレイヤー毎に異なるイベント開催期間を実現する際に、イベントの開始の起点となるタイミングを定義するエンティティです。

有効化条件必須デフォルト値の制限説明
triggerIdstring
~ 1024文字トリガーGRN
namestring
~ 128文字トリガーの名前
userIdstring
~ 128文字ユーザーID
triggeredAtlong
現在時刻トリガーを引いた日時 (UNIX時間 単位:ミリ秒)
expiresAtlong
トリガーの有効期限 (UNIX時間 単位:ミリ秒)
createdAtlong
現在時刻作成日時 (UNIX時間 単位:ミリ秒)
revisionlong0~ 9223372036854775805リビジョン

関連するメソッド

describeTriggers describeTriggersByUserId getTrigger getTriggerByUserId triggerByUserId extendTriggerByUserId triggerByStampSheet extendTriggerByStampSheet deleteTrigger deleteTriggerByUserId deleteTriggerByStampTask


Event

イベント

イベントの期間は絶対期間と相対期間の2種類存在します。
絶対期間は 2021年1月1日 00:00(UTC) ~ 2021年1月7日 23:59(UTC) のような固定の期間で、
相対期間は トリガーを引いたタイミングから 24時間 のようなゲームプレイヤー毎に異なる期間をイベント期間とするものです。

イベントには開催期間だけでなく、繰り返しが設定できるようになっており
イベント期間のうち、月曜日の 10:00 ~ 11:00 だけをイベント期間とするような設定も可能です。

有効化条件必須デフォルト値の制限説明
eventIdstring
~ 1024文字GS2-Schedule イベントGRN
namestring
~ 128文字イベントの種類名
metadatastring~ 2048文字メタデータ
scheduleTypeenum {
  “absolute”,
  “relative”
}
~ 128文字イベント期間の種類
scheduleType に指定する列挙型の定義
absoluteBeginlongイベントの開始日時 (UNIX時間 単位:ミリ秒)
absoluteEndlongイベントの終了日時 (UNIX時間 単位:ミリ秒)
relativeTriggerNamestring{scheduleType} == “relative”
~ 128文字イベントのトリガー名
scheduleType が “relative” であれば 必須
repeatSettingRepeatSetting
繰り返し設定

scheduleType に指定する列挙型の定義

定義説明
absolute固定期間
relativeプレイヤー別期間

関連するメソッド

describeEvents describeEventsByUserId describeRawEvents getEvent getEventByUserId getRawEvent


RepeatSetting

繰り返し設定

イベント期間のうち、月曜日の 10:00 ~ 11:00 だけをイベント期間とするような設定をする際に利用します。

有効化条件必須デフォルト値の制限説明
repeatTypeenum {
  “always”,
  “daily”,
  “weekly”,
  “monthly”,
  “custom”
}
“always”~ 128文字繰り返しの種類
repeatType に指定する列挙型の定義
beginDayOfMonthint{repeatType} == “monthly”
1 ~ 31イベントの繰り返し開始日(月の日数を超える場合は、最終日として扱われます)
repeatType が “monthly” であれば 必須
endDayOfMonthint{repeatType} == “monthly”
1 ~ 31イベントの繰り返し終了日(月の日数を超える場合は、最終日として扱われます)
repeatType が “monthly” であれば 必須
beginDayOfWeekenum {
  “sunday”,
  “monday”,
  “tuesday”,
  “wednesday”,
  “thursday”,
  “friday”,
  “saturday”
}
{repeatType} == “weekly”
~ 128文字イベントの繰り返し開始曜日
beginDayOfWeek に指定する列挙型の定義
repeatType が “weekly” であれば 必須
endDayOfWeekenum {
  “sunday”,
  “monday”,
  “tuesday”,
  “wednesday”,
  “thursday”,
  “friday”,
  “saturday”
}
{repeatType} == “weekly”
~ 128文字イベントの繰り返し終了曜日
endDayOfWeek に指定する列挙型の定義
repeatType が “weekly” であれば 必須
beginHourint{repeatType} in [“daily”, “weekly”, “monthly”]
~ 23イベントの繰り返し開始時間(単位:時)
repeatType が “daily”,“weekly”,“monthly"であれば 必須
endHourint{repeatType} in [“daily”, “weekly”, “monthly”]
~ 24イベントの繰り返し終了時間(単位:時)
repeatType が “daily”,“weekly”,“monthly"であれば 必須
anchorTimestamplong{repeatType} == “custom”
サイクルを開始する基準日 (UNIX時間 単位:ミリ秒)
repeatType が “custom” であれば 必須
activeDaysint{repeatType} == “custom”
1 ~ 2147483646.0サイクル内のアクティブな日数
repeatType が “custom” であれば 必須
inactiveDaysint{repeatType} == “custom”
~ 2147483646.0サイクル内のインアクティブな日数
repeatType が “custom” であれば 必須

repeatType に指定する列挙型の定義

定義説明
alwaysイベント期間 常時
dailyイベント期間のうち 毎日X時~X時
weeklyイベント期間のうち 毎週X曜日 X時~X時
monthlyイベント期間のうち 毎月X日 X時~X時
custom基準日から始まり、イベント期間中、X日アクティブ、Y日インアクティブを繰り返す

beginDayOfWeek に指定する列挙型の定義

定義説明
sunday日曜日
monday月曜日
tuesday火曜日
wednesday水曜日
thursday木曜日
friday金曜日
saturday土曜日

endDayOfWeek に指定する列挙型の定義

定義説明
sunday日曜日
monday月曜日
tuesday火曜日
wednesday水曜日
thursday木曜日
friday金曜日
saturday土曜日

関連するメソッド

createEventMaster updateEventMaster

関連するモデル

eventMaster event


RepeatSchedule

スケジュールの繰り返し状態

有効化条件必須デフォルト値の制限説明
repeatCountint
~ 2147483646繰り返し回数
currentRepeatStartAtlongリピート中のイベントの開始日時 (UNIX時間 単位:ミリ秒)
currentRepeatEndAtlongリピート中のイベントの終了日時 (UNIX時間 単位:ミリ秒)
lastRepeatEndAtlong前回のイベントの終了日時 (UNIX時間 単位:ミリ秒)
nextRepeatStartAtlong次回のイベントの開始日時 (UNIX時間 単位:ミリ秒)

関連するメソッド

getEvent getEventByUserId


CurrentEventMaster

現在有効なマスターデータ

GS2ではマスターデータの管理にJSON形式のファイルを使用します。
ファイルをアップロードすることで、実際にサーバーに設定を反映することができます。

JSONファイルを作成する方法として、マネージメントコンソール上でのマスターデータエディタを提供していますが
よりゲームの運営に相応しいツールを作成し、適切なフォーマットのJSONファイルを書き出すことでもサービスを利用可能です。

有効化条件必須デフォルト値の制限説明
namespaceIdstring
~ 1024文字現在有効なイベントマスターGRN
settingsstring
~ 5242880文字マスターデータ

関連するメソッド

exportMaster getCurrentEventMaster updateCurrentEventMaster updateCurrentEventMasterFromGitHub


GitHubCheckoutSetting

GitHubからマスターデータをチェックアウトする設定

有効化条件必須デフォルト値の制限説明
apiKeyIdstring
~ 1024文字GitHub のAPIキーGRN
repositoryNamestring
~ 1024文字リポジトリ名
sourcePathstring
~ 1024文字ソースコードのファイルパス
referenceTypeenum {
  “commit_hash”,
  “branch”,
  “tag”
}
~ 128文字コードの取得元
referenceType に指定する列挙型の定義
commitHashstring{referenceType} == “commit_hash”
~ 1024文字コミットハッシュ
referenceType が “commit_hash” であれば 必須
branchNamestring{referenceType} == “branch”
~ 1024文字ブランチ名
referenceType が “branch” であれば 必須
tagNamestring{referenceType} == “tag”
~ 1024文字タグ名
referenceType が “tag” であれば 必須

referenceType に指定する列挙型の定義

定義説明
commit_hashコミットハッシュ
branchブランチ
tagタグ

関連するメソッド

updateCurrentEventMasterFromGitHub


LogSetting

ログの書き出し設定

ログデータの書き出し設定を管理します。この型は、ログデータを書き出すために使用されるログ名前空間の識別子(Namespace ID)を保持します。
ログ名前空間IDは、ログデータを集約し、保存する対象の GS2-Log の名前空間を指定します。
この設定を通じて、この名前空間以下のAPIリクエスト・レスポンスログデータが対象の GS2-Log へ出力されるようになります。
GS2-Log にはリアルタイムでログが提供され、システムの監視や分析、デバッグなどに利用できます。

有効化条件必須デフォルト値の制限説明
loggingNamespaceIdstring
~ 1024文字ネームスペースGRN

関連するメソッド

createNamespace updateNamespace

関連するモデル

namespace


メソッド

describeNamespaces

ネームスペースの一覧を取得

Request

有効化条件必須デフォルト値の制限説明
pageTokenstring~ 1024文字データの取得を開始する位置を指定するトークン
limitint
301 ~ 1000データの取得件数

Result

説明
itemsList<Namespace>ネームスペースのリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &schedule.DescribeNamespacesRequest {
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DescribeNamespacesRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeNamespaces(
        (new DescribeNamespacesRequest())
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DescribeNamespacesRequest;
import io.gs2.schedule.result.DescribeNamespacesResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DescribeNamespacesResult result = client.describeNamespaces(
        new DescribeNamespacesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    List<Namespace> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DescribeNamespacesRequest;
using Gs2.Gs2Schedule.Result.DescribeNamespacesResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DescribeNamespacesResult> asyncResult = null;
yield return client.DescribeNamespaces(
    new Gs2.Gs2Schedule.Request.DescribeNamespacesRequest()
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.describeNamespaces(
        new Gs2Schedule.DescribeNamespacesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.describe_namespaces(
        schedule.DescribeNamespacesRequest()
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.describe_namespaces({
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
client = gs2('schedule')

api_result_handler = client.describe_namespaces_async({
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

createNamespace

ネームスペースを新規作成

Request

有効化条件必須デフォルト値の制限説明
namestring
~ 128文字ネームスペース名
descriptionstring~ 1024文字説明文
logSettingLogSettingログの出力設定

Result

説明
itemNamespace作成したネームスペース

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &schedule.CreateNamespaceRequest {
        Name: pointy.String("namespace-0001"),
        Description: nil,
        LogSetting: &schedule.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\CreateNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName("namespace-0001")
            ->withDescription(null)
            ->withLogSetting((new \Gs2\Schedule\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.CreateNamespaceRequest;
import io.gs2.schedule.result.CreateNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withLogSetting(new io.gs2.schedule.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.CreateNamespaceRequest;
using Gs2.Gs2Schedule.Result.CreateNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2Schedule.Request.CreateNamespaceRequest()
        .WithName("namespace-0001")
        .WithDescription(null)
        .WithLogSetting(new Gs2.Gs2Schedule.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.createNamespace(
        new Gs2Schedule.CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withLogSetting(new Gs2Schedule.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.create_namespace(
        schedule.CreateNamespaceRequest()
            .with_name('namespace-0001')
            .with_description(None)
            .with_log_setting(
                schedule.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.create_namespace({
    name="namespace-0001",
    description=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.create_namespace_async({
    name="namespace-0001",
    description=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getNamespaceStatus

ネームスペースの状態を取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名

Result

説明
statusstring

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &schedule.GetNamespaceStatusRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
status := result.Status
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\GetNamespaceStatusRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespaceStatus(
        (new GetNamespaceStatusRequest())
            ->withNamespaceName("namespace-0001")
    );
    $status = $result->getStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.GetNamespaceStatusRequest;
import io.gs2.schedule.result.GetNamespaceStatusResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    GetNamespaceStatusResult result = client.getNamespaceStatus(
        new GetNamespaceStatusRequest()
            .withNamespaceName("namespace-0001")
    );
    String status = result.getStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.GetNamespaceStatusRequest;
using Gs2.Gs2Schedule.Result.GetNamespaceStatusResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.GetNamespaceStatusResult> asyncResult = null;
yield return client.GetNamespaceStatus(
    new Gs2.Gs2Schedule.Request.GetNamespaceStatusRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var status = result.Status;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.getNamespaceStatus(
        new Gs2Schedule.GetNamespaceStatusRequest()
            .withNamespaceName("namespace-0001")
    );
    const status = result.getStatus();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.get_namespace_status(
        schedule.GetNamespaceStatusRequest()
            .with_namespace_name('namespace-0001')
    )
    status = result.status
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.get_namespace_status({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
status = result.status;
client = gs2('schedule')

api_result_handler = client.get_namespace_status_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
status = result.status;

getNamespace

ネームスペースを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名

Result

説明
itemNamespaceネームスペース

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &schedule.GetNamespaceRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\GetNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespace(
        (new GetNamespaceRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.GetNamespaceRequest;
import io.gs2.schedule.result.GetNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    GetNamespaceResult result = client.getNamespace(
        new GetNamespaceRequest()
            .withNamespaceName("namespace-0001")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.GetNamespaceRequest;
using Gs2.Gs2Schedule.Result.GetNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.GetNamespaceResult> asyncResult = null;
yield return client.GetNamespace(
    new Gs2.Gs2Schedule.Request.GetNamespaceRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.getNamespace(
        new Gs2Schedule.GetNamespaceRequest()
            .withNamespaceName("namespace-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.get_namespace(
        schedule.GetNamespaceRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.get_namespace({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.get_namespace_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

updateNamespace

ネームスペースを更新

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
descriptionstring~ 1024文字説明文
logSettingLogSettingログの出力設定

Result

説明
itemNamespace更新したネームスペース

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &schedule.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Description: pointy.String("description1"),
        LogSetting: &schedule.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\UpdateNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName("namespace-0001")
            ->withDescription("description1")
            ->withLogSetting((new \Gs2\Schedule\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.UpdateNamespaceRequest;
import io.gs2.schedule.result.UpdateNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withLogSetting(new io.gs2.schedule.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.UpdateNamespaceRequest;
using Gs2.Gs2Schedule.Result.UpdateNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2Schedule.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace-0001")
        .WithDescription("description1")
        .WithLogSetting(new Gs2.Gs2Schedule.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.updateNamespace(
        new Gs2Schedule.UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withLogSetting(new Gs2Schedule.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.update_namespace(
        schedule.UpdateNamespaceRequest()
            .with_namespace_name('namespace-0001')
            .with_description('description1')
            .with_log_setting(
                schedule.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.update_namespace({
    namespaceName="namespace-0001",
    description="description1",
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.update_namespace_async({
    namespaceName="namespace-0001",
    description="description1",
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteNamespace

ネームスペースを削除

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名

Result

説明
itemNamespace削除したネームスペース

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &schedule.DeleteNamespaceRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DeleteNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteNamespace(
        (new DeleteNamespaceRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DeleteNamespaceRequest;
import io.gs2.schedule.result.DeleteNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DeleteNamespaceResult result = client.deleteNamespace(
        new DeleteNamespaceRequest()
            .withNamespaceName("namespace-0001")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DeleteNamespaceRequest;
using Gs2.Gs2Schedule.Result.DeleteNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DeleteNamespaceResult> asyncResult = null;
yield return client.DeleteNamespace(
    new Gs2.Gs2Schedule.Request.DeleteNamespaceRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.deleteNamespace(
        new Gs2Schedule.DeleteNamespaceRequest()
            .withNamespaceName("namespace-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.delete_namespace(
        schedule.DeleteNamespaceRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.delete_namespace({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.delete_namespace_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getServiceVersion

マイクロサービスのバージョンを取得

Request

有効化条件必須デフォルト値の制限説明

Result

説明
itemstringバージョン

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.GetServiceVersion(
    &schedule.GetServiceVersionRequest {
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\GetServiceVersionRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getServiceVersion(
        (new GetServiceVersionRequest())
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.GetServiceVersionRequest;
import io.gs2.schedule.result.GetServiceVersionResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    GetServiceVersionResult result = client.getServiceVersion(
        new GetServiceVersionRequest()
    );
    String item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.GetServiceVersionRequest;
using Gs2.Gs2Schedule.Result.GetServiceVersionResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.GetServiceVersionResult> asyncResult = null;
yield return client.GetServiceVersion(
    new Gs2.Gs2Schedule.Request.GetServiceVersionRequest(),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.getServiceVersion(
        new Gs2Schedule.GetServiceVersionRequest()
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.get_service_version(
        schedule.GetServiceVersionRequest()
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.get_service_version({
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.get_service_version_async({
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

dumpUserDataByUserId

指定したユーザーIDに紐づくデータのダンプを取得

Request

有効化条件必須デフォルト値の制限説明
userIdstring
~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DumpUserDataByUserId(
    &schedule.DumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DumpUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->dumpUserDataByUserId(
        (new DumpUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DumpUserDataByUserIdRequest;
import io.gs2.schedule.result.DumpUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DumpUserDataByUserIdResult result = client.dumpUserDataByUserId(
        new DumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DumpUserDataByUserIdRequest;
using Gs2.Gs2Schedule.Result.DumpUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DumpUserDataByUserIdResult> asyncResult = null;
yield return client.DumpUserDataByUserId(
    new Gs2.Gs2Schedule.Request.DumpUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.dumpUserDataByUserId(
        new Gs2Schedule.DumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.dump_user_data_by_user_id(
        schedule.DumpUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.dump_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
client = gs2('schedule')

api_result_handler = client.dump_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

checkDumpUserDataByUserId

指定したユーザーIDに紐づくデータのダンプが完了しているか確認

Request

有効化条件必須デフォルト値の制限説明
userIdstring
~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
urlstring出力データのURL

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
    &schedule.CheckDumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
url := result.Url
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\CheckDumpUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkDumpUserDataByUserId(
        (new CheckDumpUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $url = $result->getUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.schedule.result.CheckDumpUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    CheckDumpUserDataByUserIdResult result = client.checkDumpUserDataByUserId(
        new CheckDumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    String url = result.getUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.CheckDumpUserDataByUserIdRequest;
using Gs2.Gs2Schedule.Result.CheckDumpUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.CheckDumpUserDataByUserIdResult> asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
    new Gs2.Gs2Schedule.Request.CheckDumpUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var url = result.Url;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.checkDumpUserDataByUserId(
        new Gs2Schedule.CheckDumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const url = result.getUrl();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.check_dump_user_data_by_user_id(
        schedule.CheckDumpUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    url = result.url
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.check_dump_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
url = result.url;
client = gs2('schedule')

api_result_handler = client.check_dump_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
url = result.url;

cleanUserDataByUserId

指定したユーザーIDに紐づくデータのダンプを取得

Request

有効化条件必須デフォルト値の制限説明
userIdstring
~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.CleanUserDataByUserId(
    &schedule.CleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\CleanUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->cleanUserDataByUserId(
        (new CleanUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.CleanUserDataByUserIdRequest;
import io.gs2.schedule.result.CleanUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    CleanUserDataByUserIdResult result = client.cleanUserDataByUserId(
        new CleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.CleanUserDataByUserIdRequest;
using Gs2.Gs2Schedule.Result.CleanUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.CleanUserDataByUserIdResult> asyncResult = null;
yield return client.CleanUserDataByUserId(
    new Gs2.Gs2Schedule.Request.CleanUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.cleanUserDataByUserId(
        new Gs2Schedule.CleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.clean_user_data_by_user_id(
        schedule.CleanUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.clean_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
client = gs2('schedule')

api_result_handler = client.clean_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

checkCleanUserDataByUserId

指定したユーザーIDに紐づくデータのダンプが完了しているか確認

Request

有効化条件必須デフォルト値の制限説明
userIdstring
~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
    &schedule.CheckCleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\CheckCleanUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkCleanUserDataByUserId(
        (new CheckCleanUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.schedule.result.CheckCleanUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    CheckCleanUserDataByUserIdResult result = client.checkCleanUserDataByUserId(
        new CheckCleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.CheckCleanUserDataByUserIdRequest;
using Gs2.Gs2Schedule.Result.CheckCleanUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.CheckCleanUserDataByUserIdResult> asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
    new Gs2.Gs2Schedule.Request.CheckCleanUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.checkCleanUserDataByUserId(
        new Gs2Schedule.CheckCleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.check_clean_user_data_by_user_id(
        schedule.CheckCleanUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.check_clean_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
client = gs2('schedule')

api_result_handler = client.check_clean_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

prepareImportUserDataByUserId

指定したユーザーIDに紐づくデータのインポートを開始

Request

有効化条件必須デフォルト値の制限説明
userIdstring
~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
uploadTokenstringアップロード後に結果を反映する際に使用するトークン
uploadUrlstringユーザーデータアップロード処理の実行に使用するURL

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
    &schedule.PrepareImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\PrepareImportUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareImportUserDataByUserId(
        (new PrepareImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $uploadToken = $result->getUploadToken();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.schedule.result.PrepareImportUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    PrepareImportUserDataByUserIdResult result = client.prepareImportUserDataByUserId(
        new PrepareImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    String uploadToken = result.getUploadToken();
    String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.PrepareImportUserDataByUserIdRequest;
using Gs2.Gs2Schedule.Result.PrepareImportUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.PrepareImportUserDataByUserIdResult> asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
    new Gs2.Gs2Schedule.Request.PrepareImportUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var uploadUrl = result.UploadUrl;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.prepareImportUserDataByUserId(
        new Gs2Schedule.PrepareImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const uploadToken = result.getUploadToken();
    const uploadUrl = result.getUploadUrl();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.prepare_import_user_data_by_user_id(
        schedule.PrepareImportUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.prepare_import_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
client = gs2('schedule')

api_result_handler = client.prepare_import_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;

importUserDataByUserId

指定したユーザーIDに紐づくデータのインポートを開始

Request

有効化条件必須デフォルト値の制限説明
userIdstring
~ 128文字ユーザーID
uploadTokenstring
~ 1024文字アップロード準備で受け取ったトークン
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.ImportUserDataByUserId(
    &schedule.ImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\ImportUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->importUserDataByUserId(
        (new ImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withUploadToken("upload-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.ImportUserDataByUserIdRequest;
import io.gs2.schedule.result.ImportUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    ImportUserDataByUserIdResult result = client.importUserDataByUserId(
        new ImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.ImportUserDataByUserIdRequest;
using Gs2.Gs2Schedule.Result.ImportUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.ImportUserDataByUserIdResult> asyncResult = null;
yield return client.ImportUserDataByUserId(
    new Gs2.Gs2Schedule.Request.ImportUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithUploadToken("upload-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.importUserDataByUserId(
        new Gs2Schedule.ImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.import_user_data_by_user_id(
        schedule.ImportUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_upload_token('upload-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.import_user_data_by_user_id({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
client = gs2('schedule')

api_result_handler = client.import_user_data_by_user_id_async({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

checkImportUserDataByUserId

指定したユーザーIDに紐づくデータのインポートが完了しているか確認

Request

有効化条件必須デフォルト値の制限説明
userIdstring
~ 128文字ユーザーID
uploadTokenstring
~ 1024文字アップロード準備で受け取ったトークン
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
urlstring出力ログのURL

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
    &schedule.CheckImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
url := result.Url
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\CheckImportUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkImportUserDataByUserId(
        (new CheckImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withUploadToken("upload-0001")
            ->withTimeOffsetToken(null)
    );
    $url = $result->getUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.CheckImportUserDataByUserIdRequest;
import io.gs2.schedule.result.CheckImportUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    CheckImportUserDataByUserIdResult result = client.checkImportUserDataByUserId(
        new CheckImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
    String url = result.getUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.CheckImportUserDataByUserIdRequest;
using Gs2.Gs2Schedule.Result.CheckImportUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.CheckImportUserDataByUserIdResult> asyncResult = null;
yield return client.CheckImportUserDataByUserId(
    new Gs2.Gs2Schedule.Request.CheckImportUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithUploadToken("upload-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var url = result.Url;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.checkImportUserDataByUserId(
        new Gs2Schedule.CheckImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
    const url = result.getUrl();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.check_import_user_data_by_user_id(
        schedule.CheckImportUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_upload_token('upload-0001')
            .with_time_offset_token(None)
    )
    url = result.url
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.check_import_user_data_by_user_id({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
url = result.url;
client = gs2('schedule')

api_result_handler = client.check_import_user_data_by_user_id_async({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
url = result.url;

describeEventMasters

イベントマスターの一覧を取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
pageTokenstring~ 1024文字データの取得を開始する位置を指定するトークン
limitint
301 ~ 1000データの取得件数

Result

説明
itemsList<EventMaster>イベントマスターのリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DescribeEventMasters(
    &schedule.DescribeEventMastersRequest {
        NamespaceName: pointy.String("namespace-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DescribeEventMastersRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeEventMasters(
        (new DescribeEventMastersRequest())
            ->withNamespaceName("namespace-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DescribeEventMastersRequest;
import io.gs2.schedule.result.DescribeEventMastersResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DescribeEventMastersResult result = client.describeEventMasters(
        new DescribeEventMastersRequest()
            .withNamespaceName("namespace-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<EventMaster> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DescribeEventMastersRequest;
using Gs2.Gs2Schedule.Result.DescribeEventMastersResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DescribeEventMastersResult> asyncResult = null;
yield return client.DescribeEventMasters(
    new Gs2.Gs2Schedule.Request.DescribeEventMastersRequest()
        .WithNamespaceName("namespace-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.describeEventMasters(
        new Gs2Schedule.DescribeEventMastersRequest()
            .withNamespaceName("namespace-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.describe_event_masters(
        schedule.DescribeEventMastersRequest()
            .with_namespace_name('namespace-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.describe_event_masters({
    namespaceName="namespace-0001",
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
client = gs2('schedule')

api_result_handler = client.describe_event_masters_async({
    namespaceName="namespace-0001",
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

createEventMaster

イベントマスターを新規作成

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
namestring
~ 128文字イベントの種類名
descriptionstring~ 1024文字説明文
metadatastring~ 2048文字メタデータ
scheduleTypeenum {
  “absolute”,
  “relative”
}
~ 128文字イベント期間の種類
scheduleType に指定する列挙型の定義
absoluteBeginlongイベントの開始日時 (UNIX時間 単位:ミリ秒)
absoluteEndlongイベントの終了日時 (UNIX時間 単位:ミリ秒)
relativeTriggerNamestring{scheduleType} == “relative”
~ 128文字イベントのトリガー名
scheduleType が “relative” であれば必須
repeatSettingRepeatSetting
繰り返し設定

scheduleType に指定する列挙型の定義

定義説明
absolute固定期間
relativeプレイヤー別期間

repeatType に指定する列挙型の定義

定義説明
alwaysイベント期間 常時
dailyイベント期間のうち 毎日X時~X時
weeklyイベント期間のうち 毎週X曜日 X時~X時
monthlyイベント期間のうち 毎月X日 X時~X時

repeatBeginDayOfWeek に指定する列挙型の定義

定義説明
sunday日曜日
monday月曜日
tuesday火曜日
wednesday水曜日
thursday木曜日
friday金曜日
saturday土曜日

repeatEndDayOfWeek に指定する列挙型の定義

定義説明
sunday日曜日
monday月曜日
tuesday火曜日
wednesday水曜日
thursday木曜日
friday金曜日
saturday土曜日

Result

説明
itemEventMaster作成したイベントマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.CreateEventMaster(
    &schedule.CreateEventMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Name: pointy.String("event-0001"),
        Description: nil,
        Metadata: nil,
        ScheduleType: pointy.String("absolute"),
        AbsoluteBegin: pointy.Int64(10000),
        AbsoluteEnd: pointy.Int64(20000),
        RelativeTriggerName: pointy.String("trigger-0001"),
        RepeatSetting: &schedule.RepeatSetting{
            BeginDayOfMonth: pointy.Int32(1),
            EndDayOfMonth: pointy.Int32(2),
            BeginDayOfWeek: pointy.String("monday"),
            EndDayOfWeek: pointy.String("sunday"),
            BeginHour: pointy.Int32(5),
            EndHour: pointy.Int32(6),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\CreateEventMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createEventMaster(
        (new CreateEventMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("event-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withScheduleType("absolute")
            ->withAbsoluteBegin(10000)
            ->withAbsoluteEnd(20000)
            ->withRelativeTriggerName("trigger-0001")
            ->withRepeatSetting((new \Gs2\Schedule\Model\RepeatSetting())
                ->withBeginDayOfMonth(1)
                ->withEndDayOfMonth(2)
                ->withBeginDayOfWeek("monday")
                ->withEndDayOfWeek("sunday")
                ->withBeginHour(5)
                ->withEndHour(6))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.CreateEventMasterRequest;
import io.gs2.schedule.result.CreateEventMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    CreateEventMasterResult result = client.createEventMaster(
        new CreateEventMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("event-0001")
            .withDescription(null)
            .withMetadata(null)
            .withScheduleType("absolute")
            .withAbsoluteBegin(10000L)
            .withAbsoluteEnd(20000L)
            .withRelativeTriggerName("trigger-0001")
            .withRepeatSetting(new io.gs2.schedule.model.RepeatSetting()
                .withBeginDayOfMonth(1)
                .withEndDayOfMonth(2)
                .withBeginDayOfWeek("monday")
                .withEndDayOfWeek("sunday")
                .withBeginHour(5)
                .withEndHour(6))
    );
    EventMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.CreateEventMasterRequest;
using Gs2.Gs2Schedule.Result.CreateEventMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.CreateEventMasterResult> asyncResult = null;
yield return client.CreateEventMaster(
    new Gs2.Gs2Schedule.Request.CreateEventMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("event-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithScheduleType("absolute")
        .WithAbsoluteBegin(10000L)
        .WithAbsoluteEnd(20000L)
        .WithRelativeTriggerName("trigger-0001")
        .WithRepeatSetting(new Gs2.Gs2Schedule.Model.RepeatSetting()
            .WithBeginDayOfMonth(1)
            .WithEndDayOfMonth(2)
            .WithBeginDayOfWeek("monday")
            .WithEndDayOfWeek("sunday")
            .WithBeginHour(5)
            .WithEndHour(6)),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.createEventMaster(
        new Gs2Schedule.CreateEventMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("event-0001")
            .withDescription(null)
            .withMetadata(null)
            .withScheduleType("absolute")
            .withAbsoluteBegin(10000)
            .withAbsoluteEnd(20000)
            .withRelativeTriggerName("trigger-0001")
            .withRepeatSetting(new Gs2Schedule.model.RepeatSetting()
                .withBeginDayOfMonth(1)
                .withEndDayOfMonth(2)
                .withBeginDayOfWeek("monday")
                .withEndDayOfWeek("sunday")
                .withBeginHour(5)
                .withEndHour(6))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.create_event_master(
        schedule.CreateEventMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('event-0001')
            .with_description(None)
            .with_metadata(None)
            .with_schedule_type('absolute')
            .with_absolute_begin(10000)
            .with_absolute_end(20000)
            .with_relative_trigger_name('trigger-0001')
            .with_repeat_setting(
                schedule.RepeatSetting()
                    .with_begin_day_of_month(1)
                    .with_end_day_of_month(2)
                    .with_begin_day_of_week('monday')
                    .with_end_day_of_week('sunday')
                    .with_begin_hour(5)
                    .with_end_hour(6))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.create_event_master({
    namespaceName="namespace-0001",
    name="event-0001",
    description=nil,
    metadata=nil,
    scheduleType="absolute",
    absoluteBegin=10000,
    absoluteEnd=20000,
    relativeTriggerName="trigger-0001",
    repeatSetting={
        beginDayOfMonth=1,
        endDayOfMonth=2,
        beginDayOfWeek="monday",
        endDayOfWeek="sunday",
        beginHour=5,
        endHour=6,
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.create_event_master_async({
    namespaceName="namespace-0001",
    name="event-0001",
    description=nil,
    metadata=nil,
    scheduleType="absolute",
    absoluteBegin=10000,
    absoluteEnd=20000,
    relativeTriggerName="trigger-0001",
    repeatSetting={
        beginDayOfMonth=1,
        endDayOfMonth=2,
        beginDayOfWeek="monday",
        endDayOfWeek="sunday",
        beginHour=5,
        endHour=6,
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getEventMaster

イベントマスターを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
eventNamestring
~ 128文字イベントの種類名

Result

説明
itemEventMasterイベントマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.GetEventMaster(
    &schedule.GetEventMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        EventName: pointy.String("event-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\GetEventMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getEventMaster(
        (new GetEventMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withEventName("event-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.GetEventMasterRequest;
import io.gs2.schedule.result.GetEventMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    GetEventMasterResult result = client.getEventMaster(
        new GetEventMasterRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
    );
    EventMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.GetEventMasterRequest;
using Gs2.Gs2Schedule.Result.GetEventMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.GetEventMasterResult> asyncResult = null;
yield return client.GetEventMaster(
    new Gs2.Gs2Schedule.Request.GetEventMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithEventName("event-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.getEventMaster(
        new Gs2Schedule.GetEventMasterRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.get_event_master(
        schedule.GetEventMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_event_name('event-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.get_event_master({
    namespaceName="namespace-0001",
    eventName="event-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.get_event_master_async({
    namespaceName="namespace-0001",
    eventName="event-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

updateEventMaster

イベントマスターを更新

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
eventNamestring
~ 128文字イベントの種類名
descriptionstring~ 1024文字説明文
metadatastring~ 2048文字メタデータ
scheduleTypeenum {
  “absolute”,
  “relative”
}
~ 128文字イベント期間の種類
scheduleType に指定する列挙型の定義
absoluteBeginlongイベントの開始日時 (UNIX時間 単位:ミリ秒)
absoluteEndlongイベントの終了日時 (UNIX時間 単位:ミリ秒)
relativeTriggerNamestring{scheduleType} == “relative”
~ 128文字イベントのトリガー名
scheduleType が “relative” であれば必須
repeatSettingRepeatSetting
繰り返し設定

scheduleType に指定する列挙型の定義

定義説明
absolute固定期間
relativeプレイヤー別期間

repeatType に指定する列挙型の定義

定義説明
alwaysイベント期間 常時
dailyイベント期間のうち 毎日X時~X時
weeklyイベント期間のうち 毎週X曜日 X時~X時
monthlyイベント期間のうち 毎月X日 X時~X時

repeatBeginDayOfWeek に指定する列挙型の定義

定義説明
sunday日曜日
monday月曜日
tuesday火曜日
wednesday水曜日
thursday木曜日
friday金曜日
saturday土曜日

repeatEndDayOfWeek に指定する列挙型の定義

定義説明
sunday日曜日
monday月曜日
tuesday火曜日
wednesday水曜日
thursday木曜日
friday金曜日
saturday土曜日

Result

説明
itemEventMaster更新したイベントマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.UpdateEventMaster(
    &schedule.UpdateEventMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        EventName: pointy.String("event-0001"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("{\"hoge\": \"fuga\"}"),
        ScheduleType: pointy.String("absolute"),
        AbsoluteBegin: pointy.Int64(20000),
        AbsoluteEnd: pointy.Int64(30000),
        RelativeTriggerName: pointy.String("trigger-0001"),
        RepeatSetting: &schedule.RepeatSetting{
            BeginDayOfMonth: pointy.Int32(1),
            EndDayOfMonth: pointy.Int32(2),
            BeginDayOfWeek: pointy.String("monday"),
            EndDayOfWeek: pointy.String("sunday"),
            BeginHour: pointy.Int32(5),
            EndHour: pointy.Int32(6),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\UpdateEventMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateEventMaster(
        (new UpdateEventMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withEventName("event-0001")
            ->withDescription("description1")
            ->withMetadata("{\"hoge\": \"fuga\"}")
            ->withScheduleType("absolute")
            ->withAbsoluteBegin(20000)
            ->withAbsoluteEnd(30000)
            ->withRelativeTriggerName("trigger-0001")
            ->withRepeatSetting((new \Gs2\Schedule\Model\RepeatSetting())
                ->withBeginDayOfMonth(1)
                ->withEndDayOfMonth(2)
                ->withBeginDayOfWeek("monday")
                ->withEndDayOfWeek("sunday")
                ->withBeginHour(5)
                ->withEndHour(6))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.UpdateEventMasterRequest;
import io.gs2.schedule.result.UpdateEventMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    UpdateEventMasterResult result = client.updateEventMaster(
        new UpdateEventMasterRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
            .withDescription("description1")
            .withMetadata("{\"hoge\": \"fuga\"}")
            .withScheduleType("absolute")
            .withAbsoluteBegin(20000L)
            .withAbsoluteEnd(30000L)
            .withRelativeTriggerName("trigger-0001")
            .withRepeatSetting(new io.gs2.schedule.model.RepeatSetting()
                .withBeginDayOfMonth(1)
                .withEndDayOfMonth(2)
                .withBeginDayOfWeek("monday")
                .withEndDayOfWeek("sunday")
                .withBeginHour(5)
                .withEndHour(6))
    );
    EventMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.UpdateEventMasterRequest;
using Gs2.Gs2Schedule.Result.UpdateEventMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.UpdateEventMasterResult> asyncResult = null;
yield return client.UpdateEventMaster(
    new Gs2.Gs2Schedule.Request.UpdateEventMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithEventName("event-0001")
        .WithDescription("description1")
        .WithMetadata("{\"hoge\": \"fuga\"}")
        .WithScheduleType("absolute")
        .WithAbsoluteBegin(20000L)
        .WithAbsoluteEnd(30000L)
        .WithRelativeTriggerName("trigger-0001")
        .WithRepeatSetting(new Gs2.Gs2Schedule.Model.RepeatSetting()
            .WithBeginDayOfMonth(1)
            .WithEndDayOfMonth(2)
            .WithBeginDayOfWeek("monday")
            .WithEndDayOfWeek("sunday")
            .WithBeginHour(5)
            .WithEndHour(6)),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.updateEventMaster(
        new Gs2Schedule.UpdateEventMasterRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
            .withDescription("description1")
            .withMetadata("{\"hoge\": \"fuga\"}")
            .withScheduleType("absolute")
            .withAbsoluteBegin(20000)
            .withAbsoluteEnd(30000)
            .withRelativeTriggerName("trigger-0001")
            .withRepeatSetting(new Gs2Schedule.model.RepeatSetting()
                .withBeginDayOfMonth(1)
                .withEndDayOfMonth(2)
                .withBeginDayOfWeek("monday")
                .withEndDayOfWeek("sunday")
                .withBeginHour(5)
                .withEndHour(6))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.update_event_master(
        schedule.UpdateEventMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_event_name('event-0001')
            .with_description('description1')
            .with_metadata('{"hoge": "fuga"}')
            .with_schedule_type('absolute')
            .with_absolute_begin(20000)
            .with_absolute_end(30000)
            .with_relative_trigger_name('trigger-0001')
            .with_repeat_setting(
                schedule.RepeatSetting()
                    .with_begin_day_of_month(1)
                    .with_end_day_of_month(2)
                    .with_begin_day_of_week('monday')
                    .with_end_day_of_week('sunday')
                    .with_begin_hour(5)
                    .with_end_hour(6))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.update_event_master({
    namespaceName="namespace-0001",
    eventName="event-0001",
    description="description1",
    metadata="{\"hoge\": \"fuga\"}",
    scheduleType="absolute",
    absoluteBegin=20000,
    absoluteEnd=30000,
    relativeTriggerName="trigger-0001",
    repeatSetting={
        beginDayOfMonth=1,
        endDayOfMonth=2,
        beginDayOfWeek="monday",
        endDayOfWeek="sunday",
        beginHour=5,
        endHour=6,
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.update_event_master_async({
    namespaceName="namespace-0001",
    eventName="event-0001",
    description="description1",
    metadata="{\"hoge\": \"fuga\"}",
    scheduleType="absolute",
    absoluteBegin=20000,
    absoluteEnd=30000,
    relativeTriggerName="trigger-0001",
    repeatSetting={
        beginDayOfMonth=1,
        endDayOfMonth=2,
        beginDayOfWeek="monday",
        endDayOfWeek="sunday",
        beginHour=5,
        endHour=6,
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteEventMaster

イベントマスターを削除

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
eventNamestring
~ 128文字イベントの種類名

Result

説明
itemEventMaster削除したイベントマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DeleteEventMaster(
    &schedule.DeleteEventMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        EventName: pointy.String("event-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DeleteEventMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteEventMaster(
        (new DeleteEventMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withEventName("event-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DeleteEventMasterRequest;
import io.gs2.schedule.result.DeleteEventMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DeleteEventMasterResult result = client.deleteEventMaster(
        new DeleteEventMasterRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
    );
    EventMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DeleteEventMasterRequest;
using Gs2.Gs2Schedule.Result.DeleteEventMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DeleteEventMasterResult> asyncResult = null;
yield return client.DeleteEventMaster(
    new Gs2.Gs2Schedule.Request.DeleteEventMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithEventName("event-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.deleteEventMaster(
        new Gs2Schedule.DeleteEventMasterRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.delete_event_master(
        schedule.DeleteEventMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_event_name('event-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.delete_event_master({
    namespaceName="namespace-0001",
    eventName="event-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.delete_event_master_async({
    namespaceName="namespace-0001",
    eventName="event-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

describeTriggers

トリガーの一覧を取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
accessTokenstring
~ 128文字アクセストークン
pageTokenstring~ 1024文字データの取得を開始する位置を指定するトークン
limitint
301 ~ 1000データの取得件数

Result

説明
itemsList<Trigger>トリガーのリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DescribeTriggers(
    &schedule.DescribeTriggersRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DescribeTriggersRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeTriggers(
        (new DescribeTriggersRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DescribeTriggersRequest;
import io.gs2.schedule.result.DescribeTriggersResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DescribeTriggersResult result = client.describeTriggers(
        new DescribeTriggersRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<Trigger> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DescribeTriggersRequest;
using Gs2.Gs2Schedule.Result.DescribeTriggersResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DescribeTriggersResult> asyncResult = null;
yield return client.DescribeTriggers(
    new Gs2.Gs2Schedule.Request.DescribeTriggersRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.describeTriggers(
        new Gs2Schedule.DescribeTriggersRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.describe_triggers(
        schedule.DescribeTriggersRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.describe_triggers({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
client = gs2('schedule')

api_result_handler = client.describe_triggers_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

describeTriggersByUserId

ユーザIDを指定してトリガーの一覧を取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
userIdstring
~ 128文字ユーザーID
pageTokenstring~ 1024文字データの取得を開始する位置を指定するトークン
limitint
301 ~ 1000データの取得件数
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemsList<Trigger>トリガーのリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DescribeTriggersByUserId(
    &schedule.DescribeTriggersByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DescribeTriggersByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeTriggersByUserId(
        (new DescribeTriggersByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DescribeTriggersByUserIdRequest;
import io.gs2.schedule.result.DescribeTriggersByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DescribeTriggersByUserIdResult result = client.describeTriggersByUserId(
        new DescribeTriggersByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<Trigger> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DescribeTriggersByUserIdRequest;
using Gs2.Gs2Schedule.Result.DescribeTriggersByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DescribeTriggersByUserIdResult> asyncResult = null;
yield return client.DescribeTriggersByUserId(
    new Gs2.Gs2Schedule.Request.DescribeTriggersByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.describeTriggersByUserId(
        new Gs2Schedule.DescribeTriggersByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.describe_triggers_by_user_id(
        schedule.DescribeTriggersByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.describe_triggers_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
client = gs2('schedule')

api_result_handler = client.describe_triggers_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

getTrigger

トリガーを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
accessTokenstring
~ 128文字アクセストークン
triggerNamestring
~ 128文字トリガーの名前

Result

説明
itemTriggerトリガー

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.GetTrigger(
    &schedule.GetTriggerRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        TriggerName: pointy.String("trigger1"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\GetTriggerRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getTrigger(
        (new GetTriggerRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withTriggerName("trigger1")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.GetTriggerRequest;
import io.gs2.schedule.result.GetTriggerResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    GetTriggerResult result = client.getTrigger(
        new GetTriggerRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTriggerName("trigger1")
    );
    Trigger item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.GetTriggerRequest;
using Gs2.Gs2Schedule.Result.GetTriggerResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.GetTriggerResult> asyncResult = null;
yield return client.GetTrigger(
    new Gs2.Gs2Schedule.Request.GetTriggerRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithTriggerName("trigger1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.getTrigger(
        new Gs2Schedule.GetTriggerRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTriggerName("trigger1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.get_trigger(
        schedule.GetTriggerRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_trigger_name('trigger1')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.get_trigger({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    triggerName="trigger1",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.get_trigger_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    triggerName="trigger1",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getTriggerByUserId

ユーザIDを指定してトリガーを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
userIdstring
~ 128文字ユーザーID
triggerNamestring
~ 128文字トリガーの名前
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemTriggerトリガー

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.GetTriggerByUserId(
    &schedule.GetTriggerByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        TriggerName: pointy.String("trigger1"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\GetTriggerByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getTriggerByUserId(
        (new GetTriggerByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withTriggerName("trigger1")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.GetTriggerByUserIdRequest;
import io.gs2.schedule.result.GetTriggerByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    GetTriggerByUserIdResult result = client.getTriggerByUserId(
        new GetTriggerByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTriggerName("trigger1")
            .withTimeOffsetToken(null)
    );
    Trigger item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.GetTriggerByUserIdRequest;
using Gs2.Gs2Schedule.Result.GetTriggerByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.GetTriggerByUserIdResult> asyncResult = null;
yield return client.GetTriggerByUserId(
    new Gs2.Gs2Schedule.Request.GetTriggerByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithTriggerName("trigger1")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.getTriggerByUserId(
        new Gs2Schedule.GetTriggerByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTriggerName("trigger1")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.get_trigger_by_user_id(
        schedule.GetTriggerByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_trigger_name('trigger1')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.get_trigger_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    triggerName="trigger1",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.get_trigger_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    triggerName="trigger1",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

triggerByUserId

ユーザIDを指定してトリガーを実行

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
triggerNamestring
~ 128文字トリガーの名前
userIdstring
~ 128文字ユーザーID
triggerStrategyenum {
  “renew”,
  “extend”,
  “drop”,
  “repeatCycleEnd”,
  “repeatCycleNextStart”,
  “absoluteEnd”
}
~ 128文字トリガーの引き方の方針
triggerStrategy に指定する列挙型の定義
ttlint{triggerStrategy} in [“renew”, “extend”, “drop”]
~ 2147483646トリガーの有効期限(秒)
eventIdstring{triggerStrategy} in [“repeatCycleEnd”, “repeatCycleNextStart”, “absoluteEnd”]
~ 1024文字イベントGRN
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

triggerStrategy に指定する列挙型の定義

定義説明
renewすでにトリガーが引かれている場合は再度新しい期間で引き直す
extendすでにトリガーが引かれている場合は期間を延長
dropすでにトリガーが引かれている場合は無視
repeatCycleEnd指定したイベントの繰り返し期間の終了日時に有効期限を迎えるようにトリガーを引く
repeatCycleNextStart指定したイベントの繰り返しで、次回の繰り返し開始日時に有効期限を迎えるようにトリガーを引く
absoluteEnd指定したイベントの終了日時に有効期限を迎えるようにトリガーを引く

Result

説明
itemTrigger引いたトリガー

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.TriggerByUserId(
    &schedule.TriggerByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        TriggerName: pointy.String("trigger1"),
        UserId: pointy.String("user-0001"),
        TriggerStrategy: pointy.String("renew"),
        Ttl: pointy.Int32(300),
        EventId: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\TriggerByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->triggerByUserId(
        (new TriggerByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withTriggerName("trigger1")
            ->withUserId("user-0001")
            ->withTriggerStrategy("renew")
            ->withTtl(300)
            ->withEventId(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.TriggerByUserIdRequest;
import io.gs2.schedule.result.TriggerByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    TriggerByUserIdResult result = client.triggerByUserId(
        new TriggerByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withTriggerName("trigger1")
            .withUserId("user-0001")
            .withTriggerStrategy("renew")
            .withTtl(300)
            .withEventId(null)
            .withTimeOffsetToken(null)
    );
    Trigger item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.TriggerByUserIdRequest;
using Gs2.Gs2Schedule.Result.TriggerByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.TriggerByUserIdResult> asyncResult = null;
yield return client.TriggerByUserId(
    new Gs2.Gs2Schedule.Request.TriggerByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithTriggerName("trigger1")
        .WithUserId("user-0001")
        .WithTriggerStrategy("renew")
        .WithTtl(300)
        .WithEventId(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.triggerByUserId(
        new Gs2Schedule.TriggerByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withTriggerName("trigger1")
            .withUserId("user-0001")
            .withTriggerStrategy("renew")
            .withTtl(300)
            .withEventId(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.trigger_by_user_id(
        schedule.TriggerByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_trigger_name('trigger1')
            .with_user_id('user-0001')
            .with_trigger_strategy('renew')
            .with_ttl(300)
            .with_event_id(None)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.trigger_by_user_id({
    namespaceName="namespace-0001",
    triggerName="trigger1",
    userId="user-0001",
    triggerStrategy="renew",
    ttl=300,
    eventId=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.trigger_by_user_id_async({
    namespaceName="namespace-0001",
    triggerName="trigger1",
    userId="user-0001",
    triggerStrategy="renew",
    ttl=300,
    eventId=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

extendTriggerByUserId

ユーザIDを指定してトリガーの期間を延長

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
triggerNamestring
~ 128文字トリガーの名前
userIdstring
~ 128文字ユーザーID
extendSecondsint
~ 2147483646トリガーを延長する期間(秒)
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemTrigger引いたトリガー

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.ExtendTriggerByUserId(
    &schedule.ExtendTriggerByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        TriggerName: pointy.String("trigger1"),
        UserId: pointy.String("user-0001"),
        ExtendSeconds: pointy.Int32(300),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\ExtendTriggerByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->extendTriggerByUserId(
        (new ExtendTriggerByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withTriggerName("trigger1")
            ->withUserId("user-0001")
            ->withExtendSeconds(300)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.ExtendTriggerByUserIdRequest;
import io.gs2.schedule.result.ExtendTriggerByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    ExtendTriggerByUserIdResult result = client.extendTriggerByUserId(
        new ExtendTriggerByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withTriggerName("trigger1")
            .withUserId("user-0001")
            .withExtendSeconds(300)
            .withTimeOffsetToken(null)
    );
    Trigger item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.ExtendTriggerByUserIdRequest;
using Gs2.Gs2Schedule.Result.ExtendTriggerByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.ExtendTriggerByUserIdResult> asyncResult = null;
yield return client.ExtendTriggerByUserId(
    new Gs2.Gs2Schedule.Request.ExtendTriggerByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithTriggerName("trigger1")
        .WithUserId("user-0001")
        .WithExtendSeconds(300)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.extendTriggerByUserId(
        new Gs2Schedule.ExtendTriggerByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withTriggerName("trigger1")
            .withUserId("user-0001")
            .withExtendSeconds(300)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.extend_trigger_by_user_id(
        schedule.ExtendTriggerByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_trigger_name('trigger1')
            .with_user_id('user-0001')
            .with_extend_seconds(300)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.extend_trigger_by_user_id({
    namespaceName="namespace-0001",
    triggerName="trigger1",
    userId="user-0001",
    extendSeconds=300,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.extend_trigger_by_user_id_async({
    namespaceName="namespace-0001",
    triggerName="trigger1",
    userId="user-0001",
    extendSeconds=300,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

triggerByStampSheet

入手アクションとしてトリガーを実行

Request

有効化条件必須デフォルト値の制限説明
stampSheetstring
~ 5242880文字トランザクション
keyIdstring
~ 1024文字暗号鍵GRN

Result

説明
itemTrigger引いたトリガー

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.TriggerByStampSheet(
    &schedule.TriggerByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\TriggerByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->triggerByStampSheet(
        (new TriggerByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.TriggerByStampSheetRequest;
import io.gs2.schedule.result.TriggerByStampSheetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    TriggerByStampSheetResult result = client.triggerByStampSheet(
        new TriggerByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    Trigger item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.TriggerByStampSheetRequest;
using Gs2.Gs2Schedule.Result.TriggerByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.TriggerByStampSheetResult> asyncResult = null;
yield return client.TriggerByStampSheet(
    new Gs2.Gs2Schedule.Request.TriggerByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.triggerByStampSheet(
        new Gs2Schedule.TriggerByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.trigger_by_stamp_sheet(
        schedule.TriggerByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.trigger_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.trigger_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

extendTriggerByStampSheet

入手アクションとしてトリガーの期間を延長

Request

有効化条件必須デフォルト値の制限説明
stampSheetstring
~ 5242880文字トランザクション
keyIdstring
~ 1024文字暗号鍵GRN

Result

説明
itemTrigger引いたトリガー

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.ExtendTriggerByStampSheet(
    &schedule.ExtendTriggerByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\ExtendTriggerByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->extendTriggerByStampSheet(
        (new ExtendTriggerByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.ExtendTriggerByStampSheetRequest;
import io.gs2.schedule.result.ExtendTriggerByStampSheetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    ExtendTriggerByStampSheetResult result = client.extendTriggerByStampSheet(
        new ExtendTriggerByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    Trigger item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.ExtendTriggerByStampSheetRequest;
using Gs2.Gs2Schedule.Result.ExtendTriggerByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.ExtendTriggerByStampSheetResult> asyncResult = null;
yield return client.ExtendTriggerByStampSheet(
    new Gs2.Gs2Schedule.Request.ExtendTriggerByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.extendTriggerByStampSheet(
        new Gs2Schedule.ExtendTriggerByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.extend_trigger_by_stamp_sheet(
        schedule.ExtendTriggerByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.extend_trigger_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.extend_trigger_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteTrigger

トリガーを削除

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
accessTokenstring
~ 128文字アクセストークン
triggerNamestring
~ 128文字トリガーの名前

Result

説明
itemTrigger削除したトリガー

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DeleteTrigger(
    &schedule.DeleteTriggerRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        TriggerName: pointy.String("trigger1"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DeleteTriggerRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteTrigger(
        (new DeleteTriggerRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withTriggerName("trigger1")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DeleteTriggerRequest;
import io.gs2.schedule.result.DeleteTriggerResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DeleteTriggerResult result = client.deleteTrigger(
        new DeleteTriggerRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTriggerName("trigger1")
    );
    Trigger item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DeleteTriggerRequest;
using Gs2.Gs2Schedule.Result.DeleteTriggerResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DeleteTriggerResult> asyncResult = null;
yield return client.DeleteTrigger(
    new Gs2.Gs2Schedule.Request.DeleteTriggerRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithTriggerName("trigger1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.deleteTrigger(
        new Gs2Schedule.DeleteTriggerRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTriggerName("trigger1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.delete_trigger(
        schedule.DeleteTriggerRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_trigger_name('trigger1')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.delete_trigger({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    triggerName="trigger1",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.delete_trigger_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    triggerName="trigger1",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteTriggerByUserId

ユーザIDを指定してトリガーを削除

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
userIdstring
~ 128文字ユーザーID
triggerNamestring
~ 128文字トリガーの名前
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemTrigger削除したトリガー

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DeleteTriggerByUserId(
    &schedule.DeleteTriggerByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        TriggerName: pointy.String("trigger1"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DeleteTriggerByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteTriggerByUserId(
        (new DeleteTriggerByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withTriggerName("trigger1")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DeleteTriggerByUserIdRequest;
import io.gs2.schedule.result.DeleteTriggerByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DeleteTriggerByUserIdResult result = client.deleteTriggerByUserId(
        new DeleteTriggerByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTriggerName("trigger1")
            .withTimeOffsetToken(null)
    );
    Trigger item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DeleteTriggerByUserIdRequest;
using Gs2.Gs2Schedule.Result.DeleteTriggerByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DeleteTriggerByUserIdResult> asyncResult = null;
yield return client.DeleteTriggerByUserId(
    new Gs2.Gs2Schedule.Request.DeleteTriggerByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithTriggerName("trigger1")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.deleteTriggerByUserId(
        new Gs2Schedule.DeleteTriggerByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTriggerName("trigger1")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.delete_trigger_by_user_id(
        schedule.DeleteTriggerByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_trigger_name('trigger1')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.delete_trigger_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    triggerName="trigger1",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.delete_trigger_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    triggerName="trigger1",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

verifyTrigger

トリガーが引かれてからの経過時間を検証

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
accessTokenstring
~ 128文字アクセストークン
triggerNamestring
~ 128文字トリガーの名前
verifyTypeenum {
  “notTriggerd”,
  “elapsed”,
  “notElapsed”
}
~ 128文字検証の種類
verifyType に指定する列挙型の定義
elapsedMinutesint{verifyType} in [“elapsed”, “notElapsed”]
~ 2147483646経過時間(分)

verifyType に指定する列挙型の定義

定義説明
notTriggerdトリガーが引かれていない
elapsed指定時間が経過している
notElapsed指定時間が経過していない

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.VerifyTrigger(
    &schedule.VerifyTriggerRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        TriggerName: pointy.String("trigger-0001"),
        VerifyType: pointy.String("elapsed"),
        ElapsedMinutes: pointy.Int32(60),
    }
)
if err != nil {
    panic("error occurred")
}
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\VerifyTriggerRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyTrigger(
        (new VerifyTriggerRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withTriggerName("trigger-0001")
            ->withVerifyType("elapsed")
            ->withElapsedMinutes(60)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.VerifyTriggerRequest;
import io.gs2.schedule.result.VerifyTriggerResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    VerifyTriggerResult result = client.verifyTrigger(
        new VerifyTriggerRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTriggerName("trigger-0001")
            .withVerifyType("elapsed")
            .withElapsedMinutes(60)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.VerifyTriggerRequest;
using Gs2.Gs2Schedule.Result.VerifyTriggerResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.VerifyTriggerResult> asyncResult = null;
yield return client.VerifyTrigger(
    new Gs2.Gs2Schedule.Request.VerifyTriggerRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithTriggerName("trigger-0001")
        .WithVerifyType("elapsed")
        .WithElapsedMinutes(60),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.verifyTrigger(
        new Gs2Schedule.VerifyTriggerRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTriggerName("trigger-0001")
            .withVerifyType("elapsed")
            .withElapsedMinutes(60)
    );
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.verify_trigger(
        schedule.VerifyTriggerRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_trigger_name('trigger-0001')
            .with_verify_type('elapsed')
            .with_elapsed_minutes(60)
    )
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.verify_trigger({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    triggerName="trigger-0001",
    verifyType="elapsed",
    elapsedMinutes=60,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
client = gs2('schedule')

api_result_handler = client.verify_trigger_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    triggerName="trigger-0001",
    verifyType="elapsed",
    elapsedMinutes=60,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

verifyTriggerByUserId

ユーザーIDを指定してトリガーが引かれてからの経過時間を検証

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
userIdstring
~ 128文字ユーザーID
triggerNamestring
~ 128文字トリガーの名前
verifyTypeenum {
  “notTriggerd”,
  “elapsed”,
  “notElapsed”
}
~ 128文字検証の種類
verifyType に指定する列挙型の定義
elapsedMinutesint{verifyType} in [“elapsed”, “notElapsed”]
~ 2147483646経過時間(分)
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

verifyType に指定する列挙型の定義

定義説明
notTriggerdトリガーが引かれていない
elapsed指定時間が経過している
notElapsed指定時間が経過していない

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.VerifyTriggerByUserId(
    &schedule.VerifyTriggerByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        TriggerName: pointy.String("trigger-0001"),
        VerifyType: pointy.String("elapsed"),
        ElapsedMinutes: pointy.Int32(60),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\VerifyTriggerByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyTriggerByUserId(
        (new VerifyTriggerByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withTriggerName("trigger-0001")
            ->withVerifyType("elapsed")
            ->withElapsedMinutes(60)
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.VerifyTriggerByUserIdRequest;
import io.gs2.schedule.result.VerifyTriggerByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    VerifyTriggerByUserIdResult result = client.verifyTriggerByUserId(
        new VerifyTriggerByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTriggerName("trigger-0001")
            .withVerifyType("elapsed")
            .withElapsedMinutes(60)
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.VerifyTriggerByUserIdRequest;
using Gs2.Gs2Schedule.Result.VerifyTriggerByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.VerifyTriggerByUserIdResult> asyncResult = null;
yield return client.VerifyTriggerByUserId(
    new Gs2.Gs2Schedule.Request.VerifyTriggerByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithTriggerName("trigger-0001")
        .WithVerifyType("elapsed")
        .WithElapsedMinutes(60)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.verifyTriggerByUserId(
        new Gs2Schedule.VerifyTriggerByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTriggerName("trigger-0001")
            .withVerifyType("elapsed")
            .withElapsedMinutes(60)
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.verify_trigger_by_user_id(
        schedule.VerifyTriggerByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_trigger_name('trigger-0001')
            .with_verify_type('elapsed')
            .with_elapsed_minutes(60)
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.verify_trigger_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    triggerName="trigger-0001",
    verifyType="elapsed",
    elapsedMinutes=60,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
client = gs2('schedule')

api_result_handler = client.verify_trigger_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    triggerName="trigger-0001",
    verifyType="elapsed",
    elapsedMinutes=60,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

deleteTriggerByStampTask

消費アクションとしてトリガーの削除を実行

Request

有効化条件必須デフォルト値の制限説明
stampTaskstring
~ 5242880文字消費アクション
keyIdstring
~ 1024文字暗号鍵GRN

Result

説明
itemTrigger削除したトリガー
newContextStackstring消費アクションの実行結果を記録したコンテキスト

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DeleteTriggerByStampTask(
    &schedule.DeleteTriggerByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
newContextStack := result.NewContextStack
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DeleteTriggerByStampTaskRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteTriggerByStampTask(
        (new DeleteTriggerByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DeleteTriggerByStampTaskRequest;
import io.gs2.schedule.result.DeleteTriggerByStampTaskResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DeleteTriggerByStampTaskResult result = client.deleteTriggerByStampTask(
        new DeleteTriggerByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    Trigger item = result.getItem();
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DeleteTriggerByStampTaskRequest;
using Gs2.Gs2Schedule.Result.DeleteTriggerByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DeleteTriggerByStampTaskResult> asyncResult = null;
yield return client.DeleteTriggerByStampTask(
    new Gs2.Gs2Schedule.Request.DeleteTriggerByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var newContextStack = result.NewContextStack;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.deleteTriggerByStampTask(
        new Gs2Schedule.DeleteTriggerByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.delete_trigger_by_stamp_task(
        schedule.DeleteTriggerByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    item = result.item
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.delete_trigger_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
newContextStack = result.newContextStack;
client = gs2('schedule')

api_result_handler = client.delete_trigger_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
newContextStack = result.newContextStack;

verifyTriggerByStampTask

検証アクションとしてトリガーが引かれてからの経過時間を検証

Request

有効化条件必須デフォルト値の制限説明
stampTaskstring
~ 5242880文字検証アクション
keyIdstring
~ 1024文字暗号鍵GRN

Result

説明
newContextStackstring検証アクションの実行結果を記録したコンテキスト

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.VerifyTriggerByStampTask(
    &schedule.VerifyTriggerByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
newContextStack := result.NewContextStack
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\VerifyTriggerByStampTaskRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyTriggerByStampTask(
        (new VerifyTriggerByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.VerifyTriggerByStampTaskRequest;
import io.gs2.schedule.result.VerifyTriggerByStampTaskResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    VerifyTriggerByStampTaskResult result = client.verifyTriggerByStampTask(
        new VerifyTriggerByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.VerifyTriggerByStampTaskRequest;
using Gs2.Gs2Schedule.Result.VerifyTriggerByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.VerifyTriggerByStampTaskResult> asyncResult = null;
yield return client.VerifyTriggerByStampTask(
    new Gs2.Gs2Schedule.Request.VerifyTriggerByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var newContextStack = result.NewContextStack;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.verifyTriggerByStampTask(
        new Gs2Schedule.VerifyTriggerByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.verify_trigger_by_stamp_task(
        schedule.VerifyTriggerByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.verify_trigger_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
newContextStack = result.newContextStack;
client = gs2('schedule')

api_result_handler = client.verify_trigger_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
newContextStack = result.newContextStack;

describeEvents

イベントの一覧を取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
accessTokenstring
~ 128文字アクセストークン

Result

説明
itemsList<Event>イベントのリスト

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DescribeEvents(
    &schedule.DescribeEventsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DescribeEventsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeEvents(
        (new DescribeEventsRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
    );
    $items = $result->getItems();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DescribeEventsRequest;
import io.gs2.schedule.result.DescribeEventsResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DescribeEventsResult result = client.describeEvents(
        new DescribeEventsRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
    );
    List<Event> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DescribeEventsRequest;
using Gs2.Gs2Schedule.Result.DescribeEventsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DescribeEventsResult> asyncResult = null;
yield return client.DescribeEvents(
    new Gs2.Gs2Schedule.Request.DescribeEventsRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.describeEvents(
        new Gs2Schedule.DescribeEventsRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.describe_events(
        schedule.DescribeEventsRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.describe_events({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
client = gs2('schedule')

api_result_handler = client.describe_events_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

describeEventsByUserId

ユーザIDを指定してイベントの一覧を取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
userIdstring
~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemsList<Event>イベントのリスト

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DescribeEventsByUserId(
    &schedule.DescribeEventsByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DescribeEventsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeEventsByUserId(
        (new DescribeEventsByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DescribeEventsByUserIdRequest;
import io.gs2.schedule.result.DescribeEventsByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DescribeEventsByUserIdResult result = client.describeEventsByUserId(
        new DescribeEventsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    List<Event> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DescribeEventsByUserIdRequest;
using Gs2.Gs2Schedule.Result.DescribeEventsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DescribeEventsByUserIdResult> asyncResult = null;
yield return client.DescribeEventsByUserId(
    new Gs2.Gs2Schedule.Request.DescribeEventsByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.describeEventsByUserId(
        new Gs2Schedule.DescribeEventsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.describe_events_by_user_id(
        schedule.DescribeEventsByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.describe_events_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
client = gs2('schedule')

api_result_handler = client.describe_events_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

describeRawEvents

イベントの一覧を取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名

Result

説明
itemsList<Event>イベントのリスト

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.DescribeRawEvents(
    &schedule.DescribeRawEventsRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\DescribeRawEventsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeRawEvents(
        (new DescribeRawEventsRequest())
            ->withNamespaceName("namespace-0001")
    );
    $items = $result->getItems();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.DescribeRawEventsRequest;
import io.gs2.schedule.result.DescribeRawEventsResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    DescribeRawEventsResult result = client.describeRawEvents(
        new DescribeRawEventsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<Event> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.DescribeRawEventsRequest;
using Gs2.Gs2Schedule.Result.DescribeRawEventsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.DescribeRawEventsResult> asyncResult = null;
yield return client.DescribeRawEvents(
    new Gs2.Gs2Schedule.Request.DescribeRawEventsRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.describeRawEvents(
        new Gs2Schedule.DescribeRawEventsRequest()
            .withNamespaceName("namespace-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.describe_raw_events(
        schedule.DescribeRawEventsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.describe_raw_events({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
client = gs2('schedule')

api_result_handler = client.describe_raw_events_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

getEvent

イベントを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
eventNamestring
~ 128文字イベントの種類名
accessTokenstring
~ 128文字アクセストークン
isInSchedulebool
true現在開催中のイベントのみ取得対象とするか

Result

説明
itemEventイベント
inSchedulebool?現在イベント期間中か
scheduleStartAtlongイベント期間開始時刻 (UNIX時間 単位:ミリ秒)
scheduleEndAtlongイベント期間終了時刻 (UNIX時間 単位:ミリ秒)
repeatScheduleRepeatSchedule繰り返し情報

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.GetEvent(
    &schedule.GetEventRequest {
        NamespaceName: pointy.String("namespace-0001"),
        EventName: pointy.String("event-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        IsInSchedule: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
inSchedule := result.InSchedule
scheduleStartAt := result.ScheduleStartAt
scheduleEndAt := result.ScheduleEndAt
repeatSchedule := result.RepeatSchedule
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\GetEventRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getEvent(
        (new GetEventRequest())
            ->withNamespaceName("namespace-0001")
            ->withEventName("event-0001")
            ->withAccessToken("accessToken-0001")
            ->withIsInSchedule(null)
    );
    $item = $result->getItem();
    $inSchedule = $result->getInSchedule();
    $scheduleStartAt = $result->getScheduleStartAt();
    $scheduleEndAt = $result->getScheduleEndAt();
    $repeatSchedule = $result->getRepeatSchedule();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.GetEventRequest;
import io.gs2.schedule.result.GetEventResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    GetEventResult result = client.getEvent(
        new GetEventRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
            .withAccessToken("accessToken-0001")
            .withIsInSchedule(null)
    );
    Event item = result.getItem();
    boolean inSchedule = result.getInSchedule();
    long scheduleStartAt = result.getScheduleStartAt();
    long scheduleEndAt = result.getScheduleEndAt();
    RepeatSchedule repeatSchedule = result.getRepeatSchedule();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.GetEventRequest;
using Gs2.Gs2Schedule.Result.GetEventResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.GetEventResult> asyncResult = null;
yield return client.GetEvent(
    new Gs2.Gs2Schedule.Request.GetEventRequest()
        .WithNamespaceName("namespace-0001")
        .WithEventName("event-0001")
        .WithAccessToken("accessToken-0001")
        .WithIsInSchedule(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var inSchedule = result.InSchedule;
var scheduleStartAt = result.ScheduleStartAt;
var scheduleEndAt = result.ScheduleEndAt;
var repeatSchedule = result.RepeatSchedule;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.getEvent(
        new Gs2Schedule.GetEventRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
            .withAccessToken("accessToken-0001")
            .withIsInSchedule(null)
    );
    const item = result.getItem();
    const inSchedule = result.getInSchedule();
    const scheduleStartAt = result.getScheduleStartAt();
    const scheduleEndAt = result.getScheduleEndAt();
    const repeatSchedule = result.getRepeatSchedule();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.get_event(
        schedule.GetEventRequest()
            .with_namespace_name('namespace-0001')
            .with_event_name('event-0001')
            .with_access_token('accessToken-0001')
            .with_is_in_schedule(None)
    )
    item = result.item
    in_schedule = result.in_schedule
    schedule_start_at = result.schedule_start_at
    schedule_end_at = result.schedule_end_at
    repeat_schedule = result.repeat_schedule
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.get_event({
    namespaceName="namespace-0001",
    eventName="event-0001",
    accessToken="accessToken-0001",
    isInSchedule=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;
client = gs2('schedule')

api_result_handler = client.get_event_async({
    namespaceName="namespace-0001",
    eventName="event-0001",
    accessToken="accessToken-0001",
    isInSchedule=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;

getEventByUserId

ユーザIDを指定してイベントを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
eventNamestring
~ 128文字イベントの種類名
userIdstring
~ 128文字ユーザーID
isInSchedulebool
true現在開催中のイベントのみ取得対象とするか
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemEventイベント
inSchedulebool?現在イベント期間中か
scheduleStartAtlongイベント期間開始時刻 (UNIX時間 単位:ミリ秒)
scheduleEndAtlongイベント期間終了時刻 (UNIX時間 単位:ミリ秒)
repeatScheduleRepeatSchedule繰り返し情報

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.GetEventByUserId(
    &schedule.GetEventByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        EventName: pointy.String("event-0001"),
        UserId: pointy.String("user-0001"),
        IsInSchedule: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
inSchedule := result.InSchedule
scheduleStartAt := result.ScheduleStartAt
scheduleEndAt := result.ScheduleEndAt
repeatSchedule := result.RepeatSchedule
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\GetEventByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getEventByUserId(
        (new GetEventByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withEventName("event-0001")
            ->withUserId("user-0001")
            ->withIsInSchedule(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $inSchedule = $result->getInSchedule();
    $scheduleStartAt = $result->getScheduleStartAt();
    $scheduleEndAt = $result->getScheduleEndAt();
    $repeatSchedule = $result->getRepeatSchedule();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.GetEventByUserIdRequest;
import io.gs2.schedule.result.GetEventByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    GetEventByUserIdResult result = client.getEventByUserId(
        new GetEventByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
            .withUserId("user-0001")
            .withIsInSchedule(null)
            .withTimeOffsetToken(null)
    );
    Event item = result.getItem();
    boolean inSchedule = result.getInSchedule();
    long scheduleStartAt = result.getScheduleStartAt();
    long scheduleEndAt = result.getScheduleEndAt();
    RepeatSchedule repeatSchedule = result.getRepeatSchedule();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.GetEventByUserIdRequest;
using Gs2.Gs2Schedule.Result.GetEventByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.GetEventByUserIdResult> asyncResult = null;
yield return client.GetEventByUserId(
    new Gs2.Gs2Schedule.Request.GetEventByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithEventName("event-0001")
        .WithUserId("user-0001")
        .WithIsInSchedule(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var inSchedule = result.InSchedule;
var scheduleStartAt = result.ScheduleStartAt;
var scheduleEndAt = result.ScheduleEndAt;
var repeatSchedule = result.RepeatSchedule;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.getEventByUserId(
        new Gs2Schedule.GetEventByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
            .withUserId("user-0001")
            .withIsInSchedule(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const inSchedule = result.getInSchedule();
    const scheduleStartAt = result.getScheduleStartAt();
    const scheduleEndAt = result.getScheduleEndAt();
    const repeatSchedule = result.getRepeatSchedule();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.get_event_by_user_id(
        schedule.GetEventByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_event_name('event-0001')
            .with_user_id('user-0001')
            .with_is_in_schedule(None)
            .with_time_offset_token(None)
    )
    item = result.item
    in_schedule = result.in_schedule
    schedule_start_at = result.schedule_start_at
    schedule_end_at = result.schedule_end_at
    repeat_schedule = result.repeat_schedule
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.get_event_by_user_id({
    namespaceName="namespace-0001",
    eventName="event-0001",
    userId="user-0001",
    isInSchedule=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;
client = gs2('schedule')

api_result_handler = client.get_event_by_user_id_async({
    namespaceName="namespace-0001",
    eventName="event-0001",
    userId="user-0001",
    isInSchedule=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;

getRawEvent

イベントを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
eventNamestring
~ 128文字イベントの種類名

Result

説明
itemEventイベント

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.GetRawEvent(
    &schedule.GetRawEventRequest {
        NamespaceName: pointy.String("namespace-0001"),
        EventName: pointy.String("event-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\GetRawEventRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getRawEvent(
        (new GetRawEventRequest())
            ->withNamespaceName("namespace-0001")
            ->withEventName("event-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.GetRawEventRequest;
import io.gs2.schedule.result.GetRawEventResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    GetRawEventResult result = client.getRawEvent(
        new GetRawEventRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
    );
    Event item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.GetRawEventRequest;
using Gs2.Gs2Schedule.Result.GetRawEventResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.GetRawEventResult> asyncResult = null;
yield return client.GetRawEvent(
    new Gs2.Gs2Schedule.Request.GetRawEventRequest()
        .WithNamespaceName("namespace-0001")
        .WithEventName("event-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.getRawEvent(
        new Gs2Schedule.GetRawEventRequest()
            .withNamespaceName("namespace-0001")
            .withEventName("event-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.get_raw_event(
        schedule.GetRawEventRequest()
            .with_namespace_name('namespace-0001')
            .with_event_name('event-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.get_raw_event({
    namespaceName="namespace-0001",
    eventName="event-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.get_raw_event_async({
    namespaceName="namespace-0001",
    eventName="event-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

verifyEvent

イベントの開催期間であるか検証

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
accessTokenstring
~ 128文字アクセストークン
eventNamestring
~ 128文字イベントの種類名
verifyTypeenum {
  “inSchedule”,
  “notInSchedule”
}
~ 128文字検証の種類
verifyType に指定する列挙型の定義

verifyType に指定する列挙型の定義

定義説明
inScheduleイベントの開催期間である
notInScheduleイベントの開催期間ではない

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.VerifyEvent(
    &schedule.VerifyEventRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        EventName: pointy.String("event-0001"),
        VerifyType: pointy.String("inSchedule"),
    }
)
if err != nil {
    panic("error occurred")
}
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\VerifyEventRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyEvent(
        (new VerifyEventRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withEventName("event-0001")
            ->withVerifyType("inSchedule")
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.VerifyEventRequest;
import io.gs2.schedule.result.VerifyEventResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    VerifyEventResult result = client.verifyEvent(
        new VerifyEventRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withEventName("event-0001")
            .withVerifyType("inSchedule")
    );
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.VerifyEventRequest;
using Gs2.Gs2Schedule.Result.VerifyEventResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.VerifyEventResult> asyncResult = null;
yield return client.VerifyEvent(
    new Gs2.Gs2Schedule.Request.VerifyEventRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithEventName("event-0001")
        .WithVerifyType("inSchedule"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.verifyEvent(
        new Gs2Schedule.VerifyEventRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withEventName("event-0001")
            .withVerifyType("inSchedule")
    );
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.verify_event(
        schedule.VerifyEventRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_event_name('event-0001')
            .with_verify_type('inSchedule')
    )
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.verify_event({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    eventName="event-0001",
    verifyType="inSchedule",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
client = gs2('schedule')

api_result_handler = client.verify_event_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    eventName="event-0001",
    verifyType="inSchedule",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

verifyEventByUserId

ユーザーIDを指定してイベントの開催期間であるかを検証

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
userIdstring
~ 128文字ユーザーID
eventNamestring
~ 128文字イベントの種類名
verifyTypeenum {
  “inSchedule”,
  “notInSchedule”
}
~ 128文字検証の種類
verifyType に指定する列挙型の定義
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

verifyType に指定する列挙型の定義

定義説明
inScheduleイベントの開催期間である
notInScheduleイベントの開催期間ではない

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.VerifyEventByUserId(
    &schedule.VerifyEventByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        EventName: pointy.String("event-0001"),
        VerifyType: pointy.String("inSchedule"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\VerifyEventByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyEventByUserId(
        (new VerifyEventByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withEventName("event-0001")
            ->withVerifyType("inSchedule")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.VerifyEventByUserIdRequest;
import io.gs2.schedule.result.VerifyEventByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    VerifyEventByUserIdResult result = client.verifyEventByUserId(
        new VerifyEventByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withEventName("event-0001")
            .withVerifyType("inSchedule")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.VerifyEventByUserIdRequest;
using Gs2.Gs2Schedule.Result.VerifyEventByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.VerifyEventByUserIdResult> asyncResult = null;
yield return client.VerifyEventByUserId(
    new Gs2.Gs2Schedule.Request.VerifyEventByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithEventName("event-0001")
        .WithVerifyType("inSchedule")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.verifyEventByUserId(
        new Gs2Schedule.VerifyEventByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withEventName("event-0001")
            .withVerifyType("inSchedule")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.verify_event_by_user_id(
        schedule.VerifyEventByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_event_name('event-0001')
            .with_verify_type('inSchedule')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.verify_event_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    eventName="event-0001",
    verifyType="inSchedule",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
client = gs2('schedule')

api_result_handler = client.verify_event_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    eventName="event-0001",
    verifyType="inSchedule",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

verifyEventByStampTask

検証アクションとしてイベントの開催期間であるかの検証を実行

Request

有効化条件必須デフォルト値の制限説明
stampTaskstring
~ 5242880文字検証アクション
keyIdstring
~ 1024文字暗号鍵GRN

Result

説明
newContextStackstring検証アクションの実行結果を記録したコンテキスト

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.VerifyEventByStampTask(
    &schedule.VerifyEventByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
newContextStack := result.NewContextStack
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\VerifyEventByStampTaskRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyEventByStampTask(
        (new VerifyEventByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.VerifyEventByStampTaskRequest;
import io.gs2.schedule.result.VerifyEventByStampTaskResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    VerifyEventByStampTaskResult result = client.verifyEventByStampTask(
        new VerifyEventByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.VerifyEventByStampTaskRequest;
using Gs2.Gs2Schedule.Result.VerifyEventByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.VerifyEventByStampTaskResult> asyncResult = null;
yield return client.VerifyEventByStampTask(
    new Gs2.Gs2Schedule.Request.VerifyEventByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var newContextStack = result.NewContextStack;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.verifyEventByStampTask(
        new Gs2Schedule.VerifyEventByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.verify_event_by_stamp_task(
        schedule.VerifyEventByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.verify_event_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
newContextStack = result.newContextStack;
client = gs2('schedule')

api_result_handler = client.verify_event_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
newContextStack = result.newContextStack;

exportMaster

現在有効なイベントスケジュールマスターのマスターデータをエクスポート

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名

Result

説明
itemCurrentEventMaster現在有効なイベントスケジュールマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.ExportMaster(
    &schedule.ExportMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\ExportMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->exportMaster(
        (new ExportMasterRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.ExportMasterRequest;
import io.gs2.schedule.result.ExportMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    ExportMasterResult result = client.exportMaster(
        new ExportMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentEventMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.ExportMasterRequest;
using Gs2.Gs2Schedule.Result.ExportMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.ExportMasterResult> asyncResult = null;
yield return client.ExportMaster(
    new Gs2.Gs2Schedule.Request.ExportMasterRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.exportMaster(
        new Gs2Schedule.ExportMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.export_master(
        schedule.ExportMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.export_master({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.export_master_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getCurrentEventMaster

現在有効なイベントスケジュールマスターを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名

Result

説明
itemCurrentEventMaster現在有効なイベントスケジュールマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.GetCurrentEventMaster(
    &schedule.GetCurrentEventMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\GetCurrentEventMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getCurrentEventMaster(
        (new GetCurrentEventMasterRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.GetCurrentEventMasterRequest;
import io.gs2.schedule.result.GetCurrentEventMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    GetCurrentEventMasterResult result = client.getCurrentEventMaster(
        new GetCurrentEventMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentEventMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.GetCurrentEventMasterRequest;
using Gs2.Gs2Schedule.Result.GetCurrentEventMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.GetCurrentEventMasterResult> asyncResult = null;
yield return client.GetCurrentEventMaster(
    new Gs2.Gs2Schedule.Request.GetCurrentEventMasterRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.getCurrentEventMaster(
        new Gs2Schedule.GetCurrentEventMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.get_current_event_master(
        schedule.GetCurrentEventMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.get_current_event_master({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.get_current_event_master_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

preUpdateCurrentEventMaster

現在有効なマスターデータを更新

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名

Result

説明
uploadTokenstringアップロード後に結果を反映する際に使用するトークン
uploadUrlstringアップロード処理の実行に使用するURL

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.PreUpdateCurrentEventMaster(
    &schedule.PreUpdateCurrentEventMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\PreUpdateCurrentEventMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->preUpdateCurrentEventMaster(
        (new PreUpdateCurrentEventMasterRequest())
            ->withNamespaceName("namespace-0001")
    );
    $uploadToken = $result->getUploadToken();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.PreUpdateCurrentEventMasterRequest;
import io.gs2.schedule.result.PreUpdateCurrentEventMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    PreUpdateCurrentEventMasterResult result = client.preUpdateCurrentEventMaster(
        new PreUpdateCurrentEventMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    String uploadToken = result.getUploadToken();
    String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.PreUpdateCurrentEventMasterRequest;
using Gs2.Gs2Schedule.Result.PreUpdateCurrentEventMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.PreUpdateCurrentEventMasterResult> asyncResult = null;
yield return client.PreUpdateCurrentEventMaster(
    new Gs2.Gs2Schedule.Request.PreUpdateCurrentEventMasterRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var uploadUrl = result.UploadUrl;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.preUpdateCurrentEventMaster(
        new Gs2Schedule.PreUpdateCurrentEventMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    const uploadToken = result.getUploadToken();
    const uploadUrl = result.getUploadUrl();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.pre_update_current_event_master(
        schedule.PreUpdateCurrentEventMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.pre_update_current_event_master({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
client = gs2('schedule')

api_result_handler = client.pre_update_current_event_master_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;

updateCurrentEventMaster

現在有効なイベントスケジュールマスターを更新

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
modeenum {
  “direct”,
  “preUpload”
}
“direct”~ 128文字更新モード
mode に指定する列挙型の定義
settingsstring{mode} == “direct”
~ 5242880文字マスターデータ
mode が “direct” であれば必須
uploadTokenstring{mode} == “preUpload”
~ 1024文字プレアップロードで取得したトークン
mode が “preUpload” であれば必須

mode に指定する列挙型の定義

定義説明
direct設定を直接更新
preUpload設定をアップロードしてから更新

Result

説明
itemCurrentEventMaster更新した現在有効なイベントスケジュールマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentEventMaster(
    &schedule.UpdateCurrentEventMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Mode: nil,
        Settings: pointy.String("{\n  \"version\": \"2019-03-31\",\n  \"events\": [\n    {\n      \"name\": \"event-0001\",\n      \"metadata\": \"EVENT_0001\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 10000,\n      \"absoluteEnd\": 20000,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"event-0002\",\n      \"metadata\": \"EVENT_0002\",\n      \"scheduleType\": \"relative\",\n      \"relativeTriggerName\": \"trigger-0001\",\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"daily-0001\",\n      \"metadata\": \"EVENT_0003\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569369600000,\n      \"absoluteEnd\": 1569456000000,\n      \"repeatType\": \"daily\",\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"daily-0002\",\n      \"metadata\": \"EVENT_0004\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569369600000,\n      \"absoluteEnd\": 1569456000000,\n      \"repeatType\": \"daily\",\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 1,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"weekly-0001\",\n      \"metadata\": \"EVENT_0005\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569888000000,\n      \"absoluteEnd\": 1570406400000,\n      \"repeatType\": \"weekly\",\n      \"repeatBeginDayOfWeek\": \"tuesday\",\n      \"repeatEndDayOfWeek\": \"wednesday\",\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"weekly-0002\",\n      \"metadata\": \"EVENT_0006\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569888000000,\n      \"absoluteEnd\": 1570406400000,\n      \"repeatType\": \"weekly\",\n      \"repeatBeginDayOfWeek\": \"wednesday\",\n      \"repeatEndDayOfWeek\": \"tuesday\",\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 1,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"monthly-0001\",\n      \"metadata\": \"EVENT_0007\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1570406400000,\n      \"absoluteEnd\": 1575158400000,\n      \"repeatType\": \"monthly\",\n      \"repeatBeginDayOfMonth\": 10,\n      \"repeatEndDayOfMonth\": 15,\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"monthly-0002\",\n      \"metadata\": \"EVENT_0008\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1570406400000,\n      \"absoluteEnd\": 1575158400000,\n      \"repeatType\": \"monthly\",\n      \"repeatBeginDayOfMonth\": 16,\n      \"repeatEndDayOfMonth\": 9,\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 0,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    }\n  ]\n}"),
        UploadToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\UpdateCurrentEventMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateCurrentEventMaster(
        (new UpdateCurrentEventMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withMode(null)
            ->withSettings("{\n  \"version\": \"2019-03-31\",\n  \"events\": [\n    {\n      \"name\": \"event-0001\",\n      \"metadata\": \"EVENT_0001\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 10000,\n      \"absoluteEnd\": 20000,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"event-0002\",\n      \"metadata\": \"EVENT_0002\",\n      \"scheduleType\": \"relative\",\n      \"relativeTriggerName\": \"trigger-0001\",\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"daily-0001\",\n      \"metadata\": \"EVENT_0003\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569369600000,\n      \"absoluteEnd\": 1569456000000,\n      \"repeatType\": \"daily\",\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"daily-0002\",\n      \"metadata\": \"EVENT_0004\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569369600000,\n      \"absoluteEnd\": 1569456000000,\n      \"repeatType\": \"daily\",\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 1,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"weekly-0001\",\n      \"metadata\": \"EVENT_0005\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569888000000,\n      \"absoluteEnd\": 1570406400000,\n      \"repeatType\": \"weekly\",\n      \"repeatBeginDayOfWeek\": \"tuesday\",\n      \"repeatEndDayOfWeek\": \"wednesday\",\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"weekly-0002\",\n      \"metadata\": \"EVENT_0006\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569888000000,\n      \"absoluteEnd\": 1570406400000,\n      \"repeatType\": \"weekly\",\n      \"repeatBeginDayOfWeek\": \"wednesday\",\n      \"repeatEndDayOfWeek\": \"tuesday\",\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 1,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"monthly-0001\",\n      \"metadata\": \"EVENT_0007\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1570406400000,\n      \"absoluteEnd\": 1575158400000,\n      \"repeatType\": \"monthly\",\n      \"repeatBeginDayOfMonth\": 10,\n      \"repeatEndDayOfMonth\": 15,\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"monthly-0002\",\n      \"metadata\": \"EVENT_0008\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1570406400000,\n      \"absoluteEnd\": 1575158400000,\n      \"repeatType\": \"monthly\",\n      \"repeatBeginDayOfMonth\": 16,\n      \"repeatEndDayOfMonth\": 9,\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 0,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    }\n  ]\n}")
            ->withUploadToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.UpdateCurrentEventMasterRequest;
import io.gs2.schedule.result.UpdateCurrentEventMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    UpdateCurrentEventMasterResult result = client.updateCurrentEventMaster(
        new UpdateCurrentEventMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode(null)
            .withSettings("{\n  \"version\": \"2019-03-31\",\n  \"events\": [\n    {\n      \"name\": \"event-0001\",\n      \"metadata\": \"EVENT_0001\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 10000,\n      \"absoluteEnd\": 20000,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"event-0002\",\n      \"metadata\": \"EVENT_0002\",\n      \"scheduleType\": \"relative\",\n      \"relativeTriggerName\": \"trigger-0001\",\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"daily-0001\",\n      \"metadata\": \"EVENT_0003\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569369600000,\n      \"absoluteEnd\": 1569456000000,\n      \"repeatType\": \"daily\",\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"daily-0002\",\n      \"metadata\": \"EVENT_0004\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569369600000,\n      \"absoluteEnd\": 1569456000000,\n      \"repeatType\": \"daily\",\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 1,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"weekly-0001\",\n      \"metadata\": \"EVENT_0005\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569888000000,\n      \"absoluteEnd\": 1570406400000,\n      \"repeatType\": \"weekly\",\n      \"repeatBeginDayOfWeek\": \"tuesday\",\n      \"repeatEndDayOfWeek\": \"wednesday\",\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"weekly-0002\",\n      \"metadata\": \"EVENT_0006\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569888000000,\n      \"absoluteEnd\": 1570406400000,\n      \"repeatType\": \"weekly\",\n      \"repeatBeginDayOfWeek\": \"wednesday\",\n      \"repeatEndDayOfWeek\": \"tuesday\",\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 1,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"monthly-0001\",\n      \"metadata\": \"EVENT_0007\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1570406400000,\n      \"absoluteEnd\": 1575158400000,\n      \"repeatType\": \"monthly\",\n      \"repeatBeginDayOfMonth\": 10,\n      \"repeatEndDayOfMonth\": 15,\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"monthly-0002\",\n      \"metadata\": \"EVENT_0008\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1570406400000,\n      \"absoluteEnd\": 1575158400000,\n      \"repeatType\": \"monthly\",\n      \"repeatBeginDayOfMonth\": 16,\n      \"repeatEndDayOfMonth\": 9,\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 0,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    }\n  ]\n}")
            .withUploadToken(null)
    );
    CurrentEventMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.UpdateCurrentEventMasterRequest;
using Gs2.Gs2Schedule.Result.UpdateCurrentEventMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.UpdateCurrentEventMasterResult> asyncResult = null;
yield return client.UpdateCurrentEventMaster(
    new Gs2.Gs2Schedule.Request.UpdateCurrentEventMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithMode(null)
        .WithSettings("{\n  \"version\": \"2019-03-31\",\n  \"events\": [\n    {\n      \"name\": \"event-0001\",\n      \"metadata\": \"EVENT_0001\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 10000,\n      \"absoluteEnd\": 20000,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"event-0002\",\n      \"metadata\": \"EVENT_0002\",\n      \"scheduleType\": \"relative\",\n      \"relativeTriggerName\": \"trigger-0001\",\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"daily-0001\",\n      \"metadata\": \"EVENT_0003\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569369600000,\n      \"absoluteEnd\": 1569456000000,\n      \"repeatType\": \"daily\",\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"daily-0002\",\n      \"metadata\": \"EVENT_0004\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569369600000,\n      \"absoluteEnd\": 1569456000000,\n      \"repeatType\": \"daily\",\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 1,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"weekly-0001\",\n      \"metadata\": \"EVENT_0005\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569888000000,\n      \"absoluteEnd\": 1570406400000,\n      \"repeatType\": \"weekly\",\n      \"repeatBeginDayOfWeek\": \"tuesday\",\n      \"repeatEndDayOfWeek\": \"wednesday\",\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"weekly-0002\",\n      \"metadata\": \"EVENT_0006\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569888000000,\n      \"absoluteEnd\": 1570406400000,\n      \"repeatType\": \"weekly\",\n      \"repeatBeginDayOfWeek\": \"wednesday\",\n      \"repeatEndDayOfWeek\": \"tuesday\",\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 1,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"monthly-0001\",\n      \"metadata\": \"EVENT_0007\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1570406400000,\n      \"absoluteEnd\": 1575158400000,\n      \"repeatType\": \"monthly\",\n      \"repeatBeginDayOfMonth\": 10,\n      \"repeatEndDayOfMonth\": 15,\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"monthly-0002\",\n      \"metadata\": \"EVENT_0008\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1570406400000,\n      \"absoluteEnd\": 1575158400000,\n      \"repeatType\": \"monthly\",\n      \"repeatBeginDayOfMonth\": 16,\n      \"repeatEndDayOfMonth\": 9,\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 0,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    }\n  ]\n}")
        .WithUploadToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.updateCurrentEventMaster(
        new Gs2Schedule.UpdateCurrentEventMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode(null)
            .withSettings("{\n  \"version\": \"2019-03-31\",\n  \"events\": [\n    {\n      \"name\": \"event-0001\",\n      \"metadata\": \"EVENT_0001\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 10000,\n      \"absoluteEnd\": 20000,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"event-0002\",\n      \"metadata\": \"EVENT_0002\",\n      \"scheduleType\": \"relative\",\n      \"relativeTriggerName\": \"trigger-0001\",\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"daily-0001\",\n      \"metadata\": \"EVENT_0003\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569369600000,\n      \"absoluteEnd\": 1569456000000,\n      \"repeatType\": \"daily\",\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"daily-0002\",\n      \"metadata\": \"EVENT_0004\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569369600000,\n      \"absoluteEnd\": 1569456000000,\n      \"repeatType\": \"daily\",\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 1,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"weekly-0001\",\n      \"metadata\": \"EVENT_0005\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569888000000,\n      \"absoluteEnd\": 1570406400000,\n      \"repeatType\": \"weekly\",\n      \"repeatBeginDayOfWeek\": \"tuesday\",\n      \"repeatEndDayOfWeek\": \"wednesday\",\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"weekly-0002\",\n      \"metadata\": \"EVENT_0006\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1569888000000,\n      \"absoluteEnd\": 1570406400000,\n      \"repeatType\": \"weekly\",\n      \"repeatBeginDayOfWeek\": \"wednesday\",\n      \"repeatEndDayOfWeek\": \"tuesday\",\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 1,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"monthly-0001\",\n      \"metadata\": \"EVENT_0007\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1570406400000,\n      \"absoluteEnd\": 1575158400000,\n      \"repeatType\": \"monthly\",\n      \"repeatBeginDayOfMonth\": 10,\n      \"repeatEndDayOfMonth\": 15,\n      \"repeatBeginHour\": 1,\n      \"repeatEndHour\": 2,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    },\n    {\n      \"name\": \"monthly-0002\",\n      \"metadata\": \"EVENT_0008\",\n      \"scheduleType\": \"absolute\",\n      \"absoluteBegin\": 1570406400000,\n      \"absoluteEnd\": 1575158400000,\n      \"repeatType\": \"monthly\",\n      \"repeatBeginDayOfMonth\": 16,\n      \"repeatEndDayOfMonth\": 9,\n      \"repeatBeginHour\": 3,\n      \"repeatEndHour\": 0,\n      \"repeatSetting\": {\n        \"repeatType\": \"always\",\n        \"beginDayOfMonth\": 1,\n        \"endDayOfMonth\": 1,\n        \"beginHour\": 0,\n        \"endHour\": 0,\n        \"activeDays\": 1,\n        \"inactiveDays\": 0\n    }\n    }\n  ]\n}")
            .withUploadToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.update_current_event_master(
        schedule.UpdateCurrentEventMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_mode(None)
            .with_settings('{\n  "version": "2019-03-31",\n  "events": [\n    {\n      "name": "event-0001",\n      "metadata": "EVENT_0001",\n      "scheduleType": "absolute",\n      "absoluteBegin": 10000,\n      "absoluteEnd": 20000,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "event-0002",\n      "metadata": "EVENT_0002",\n      "scheduleType": "relative",\n      "relativeTriggerName": "trigger-0001",\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "daily-0001",\n      "metadata": "EVENT_0003",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569369600000,\n      "absoluteEnd": 1569456000000,\n      "repeatType": "daily",\n      "repeatBeginHour": 1,\n      "repeatEndHour": 2,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "daily-0002",\n      "metadata": "EVENT_0004",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569369600000,\n      "absoluteEnd": 1569456000000,\n      "repeatType": "daily",\n      "repeatBeginHour": 3,\n      "repeatEndHour": 1,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "weekly-0001",\n      "metadata": "EVENT_0005",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569888000000,\n      "absoluteEnd": 1570406400000,\n      "repeatType": "weekly",\n      "repeatBeginDayOfWeek": "tuesday",\n      "repeatEndDayOfWeek": "wednesday",\n      "repeatBeginHour": 1,\n      "repeatEndHour": 2,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "weekly-0002",\n      "metadata": "EVENT_0006",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569888000000,\n      "absoluteEnd": 1570406400000,\n      "repeatType": "weekly",\n      "repeatBeginDayOfWeek": "wednesday",\n      "repeatEndDayOfWeek": "tuesday",\n      "repeatBeginHour": 3,\n      "repeatEndHour": 1,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "monthly-0001",\n      "metadata": "EVENT_0007",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1570406400000,\n      "absoluteEnd": 1575158400000,\n      "repeatType": "monthly",\n      "repeatBeginDayOfMonth": 10,\n      "repeatEndDayOfMonth": 15,\n      "repeatBeginHour": 1,\n      "repeatEndHour": 2,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "monthly-0002",\n      "metadata": "EVENT_0008",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1570406400000,\n      "absoluteEnd": 1575158400000,\n      "repeatType": "monthly",\n      "repeatBeginDayOfMonth": 16,\n      "repeatEndDayOfMonth": 9,\n      "repeatBeginHour": 3,\n      "repeatEndHour": 0,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    }\n  ]\n}')
            .with_upload_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.update_current_event_master({
    namespaceName="namespace-0001",
    mode=nil,
    settings="{\n  "version": "2019-03-31",\n  "events": [\n    {\n      "name": "event-0001",\n      "metadata": "EVENT_0001",\n      "scheduleType": "absolute",\n      "absoluteBegin": 10000,\n      "absoluteEnd": 20000,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "event-0002",\n      "metadata": "EVENT_0002",\n      "scheduleType": "relative",\n      "relativeTriggerName": "trigger-0001",\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "daily-0001",\n      "metadata": "EVENT_0003",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569369600000,\n      "absoluteEnd": 1569456000000,\n      "repeatType": "daily",\n      "repeatBeginHour": 1,\n      "repeatEndHour": 2,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "daily-0002",\n      "metadata": "EVENT_0004",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569369600000,\n      "absoluteEnd": 1569456000000,\n      "repeatType": "daily",\n      "repeatBeginHour": 3,\n      "repeatEndHour": 1,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "weekly-0001",\n      "metadata": "EVENT_0005",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569888000000,\n      "absoluteEnd": 1570406400000,\n      "repeatType": "weekly",\n      "repeatBeginDayOfWeek": "tuesday",\n      "repeatEndDayOfWeek": "wednesday",\n      "repeatBeginHour": 1,\n      "repeatEndHour": 2,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "weekly-0002",\n      "metadata": "EVENT_0006",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569888000000,\n      "absoluteEnd": 1570406400000,\n      "repeatType": "weekly",\n      "repeatBeginDayOfWeek": "wednesday",\n      "repeatEndDayOfWeek": "tuesday",\n      "repeatBeginHour": 3,\n      "repeatEndHour": 1,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "monthly-0001",\n      "metadata": "EVENT_0007",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1570406400000,\n      "absoluteEnd": 1575158400000,\n      "repeatType": "monthly",\n      "repeatBeginDayOfMonth": 10,\n      "repeatEndDayOfMonth": 15,\n      "repeatBeginHour": 1,\n      "repeatEndHour": 2,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "monthly-0002",\n      "metadata": "EVENT_0008",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1570406400000,\n      "absoluteEnd": 1575158400000,\n      "repeatType": "monthly",\n      "repeatBeginDayOfMonth": 16,\n      "repeatEndDayOfMonth": 9,\n      "repeatBeginHour": 3,\n      "repeatEndHour": 0,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    }\n  ]\n}",
    uploadToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.update_current_event_master_async({
    namespaceName="namespace-0001",
    mode=nil,
    settings="{\n  "version": "2019-03-31",\n  "events": [\n    {\n      "name": "event-0001",\n      "metadata": "EVENT_0001",\n      "scheduleType": "absolute",\n      "absoluteBegin": 10000,\n      "absoluteEnd": 20000,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "event-0002",\n      "metadata": "EVENT_0002",\n      "scheduleType": "relative",\n      "relativeTriggerName": "trigger-0001",\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "daily-0001",\n      "metadata": "EVENT_0003",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569369600000,\n      "absoluteEnd": 1569456000000,\n      "repeatType": "daily",\n      "repeatBeginHour": 1,\n      "repeatEndHour": 2,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "daily-0002",\n      "metadata": "EVENT_0004",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569369600000,\n      "absoluteEnd": 1569456000000,\n      "repeatType": "daily",\n      "repeatBeginHour": 3,\n      "repeatEndHour": 1,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "weekly-0001",\n      "metadata": "EVENT_0005",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569888000000,\n      "absoluteEnd": 1570406400000,\n      "repeatType": "weekly",\n      "repeatBeginDayOfWeek": "tuesday",\n      "repeatEndDayOfWeek": "wednesday",\n      "repeatBeginHour": 1,\n      "repeatEndHour": 2,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "weekly-0002",\n      "metadata": "EVENT_0006",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1569888000000,\n      "absoluteEnd": 1570406400000,\n      "repeatType": "weekly",\n      "repeatBeginDayOfWeek": "wednesday",\n      "repeatEndDayOfWeek": "tuesday",\n      "repeatBeginHour": 3,\n      "repeatEndHour": 1,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "monthly-0001",\n      "metadata": "EVENT_0007",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1570406400000,\n      "absoluteEnd": 1575158400000,\n      "repeatType": "monthly",\n      "repeatBeginDayOfMonth": 10,\n      "repeatEndDayOfMonth": 15,\n      "repeatBeginHour": 1,\n      "repeatEndHour": 2,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    },\n    {\n      "name": "monthly-0002",\n      "metadata": "EVENT_0008",\n      "scheduleType": "absolute",\n      "absoluteBegin": 1570406400000,\n      "absoluteEnd": 1575158400000,\n      "repeatType": "monthly",\n      "repeatBeginDayOfMonth": 16,\n      "repeatEndDayOfMonth": 9,\n      "repeatBeginHour": 3,\n      "repeatEndHour": 0,\n      "repeatSetting": {\n        "repeatType": "always",\n        "beginDayOfMonth": 1,\n        "endDayOfMonth": 1,\n        "beginHour": 0,\n        "endHour": 0,\n        "activeDays": 1,\n        "inactiveDays": 0\n    }\n    }\n  ]\n}",
    uploadToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

updateCurrentEventMasterFromGitHub

現在有効なイベントスケジュールマスターを更新

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring
~ 128文字ネームスペース名
checkoutSettingGitHubCheckoutSetting
GitHubからマスターデータをチェックアウトしてくる設定

Result

説明
itemCurrentEventMaster更新した現在有効なイベントスケジュールマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/schedule"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := schedule.Gs2ScheduleRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentEventMasterFromGitHub(
    &schedule.UpdateCurrentEventMasterFromGitHubRequest {
        NamespaceName: pointy.String("namespace-0001"),
        CheckoutSetting: &schedule.GitHubCheckoutSetting{
            ApiKeyId: pointy.String("apiKeyId-0001"),
            RepositoryName: pointy.String("gs2io/master-data"),
            SourcePath: pointy.String("path/to/file.json"),
            ReferenceType: pointy.String("branch"),
            BranchName: pointy.String("develop"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Schedule\Gs2ScheduleRestClient;
use Gs2\Schedule\Request\UpdateCurrentEventMasterFromGitHubRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateCurrentEventMasterFromGitHub(
        (new UpdateCurrentEventMasterFromGitHubRequest())
            ->withNamespaceName("namespace-0001")
            ->withCheckoutSetting((new GitHubCheckoutSetting())
                ->withApiKeyId("apiKeyId-0001")
                ->withRepositoryName("gs2io/master-data")
                ->withSourcePath("path/to/file.json")
                ->withReferenceType("branch")
                ->withBranchName("develop")
            )
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.schedule.rest.Gs2ScheduleRestClient;
import io.gs2.schedule.request.UpdateCurrentEventMasterFromGitHubRequest;
import io.gs2.schedule.result.UpdateCurrentEventMasterFromGitHubResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session);

try {
    UpdateCurrentEventMasterFromGitHubResult result = client.updateCurrentEventMasterFromGitHub(
        new UpdateCurrentEventMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    CurrentEventMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Schedule.Gs2ScheduleRestClient;
using Gs2.Gs2Schedule.Request.UpdateCurrentEventMasterFromGitHubRequest;
using Gs2.Gs2Schedule.Result.UpdateCurrentEventMasterFromGitHubResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2ScheduleRestClient(session);

AsyncResult<Gs2.Gs2Schedule.Result.UpdateCurrentEventMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentEventMasterFromGitHub(
    new Gs2.Gs2Schedule.Request.UpdateCurrentEventMasterFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithCheckoutSetting(new Gs2.Gs2Schedule.Model.GitHubCheckoutSetting()
            .WithApiKeyId("apiKeyId-0001")
            .WithRepositoryName("gs2io/master-data")
            .WithSourcePath("path/to/file.json")
            .WithReferenceType("branch")
            .WithBranchName("develop")
        ),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Schedule from '@/gs2/schedule';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Schedule.Gs2ScheduleRestClient(session);

try {
    const result = await client.updateCurrentEventMasterFromGitHub(
        new Gs2Schedule.UpdateCurrentEventMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new Gs2Schedule.model.GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import schedule

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = schedule.Gs2ScheduleRestClient(session)

try:
    result = client.update_current_event_master_from_git_hub(
        schedule.UpdateCurrentEventMasterFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_checkout_setting(schedule.GitHubCheckoutSetting()
                .with_api_key_id('apiKeyId-0001')
                .with_repository_name('gs2io/master-data')
                .with_source_path('path/to/file.json')
                .with_reference_type('branch')
                .with_branch_name('develop')
            )
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('schedule')

api_result = client.update_current_event_master_from_git_hub({
    namespaceName="namespace-0001",
    checkoutSetting={
        api_key_id="apiKeyId-0001",
        repository_name="gs2io/master-data",
        source_path="path/to/file.json",
        reference_type="branch",
        branch_name="develop",
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
client = gs2('schedule')

api_result_handler = client.update_current_event_master_from_git_hub_async({
    namespaceName="namespace-0001",
    checkoutSetting={
        api_key_id="apiKeyId-0001",
        repository_name="gs2io/master-data",
        source_path="path/to/file.json",
        reference_type="branch",
        branch_name="develop",
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;