NAV Navbar
Python Java GS2-Formation
 

GS2-Schedule

ゲーム内のイベントの予定を管理します。

このサービスを単独で使うことはなく、 GS2-Showcase や GS2-Quest などと連携して、イベント開催期間のみストアに陳列する商品やクエストを実現します。

GS2-Schedule のデータ構造は以下です。

モデル

Namespace

ネームスペース

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false ネームスペースの説明
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

EventMaster

イベントマスター

イベントの開催期間を定義します。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
eventId string true イベントマスター
name string true イベントの種類名
description string false イベントマスターの説明
metadata string false イベントの種類のメタデータ
scheduleType string true イベント期間の種類
repeatType string true 繰り返しの種類
absoluteBegin long true イベントの開始日時
absoluteEnd long true イベントの終了日時
repeatBeginDayOfMonth integer true イベントの繰り返し開始日
repeatEndDayOfMonth integer true イベントの繰り返し終了日
repeatBeginDayOfWeek string true イベントの繰り返し開始曜日
repeatEndDayOfWeek string true イベントの繰り返し終了曜日
repeatBeginHour integer true イベントの繰り返し開始時間
repeatEndHour integer true イベントの繰り返し終了時間
relativeTriggerName string true イベントの開始トリガー名
relativeDuration integer true イベントの開催期間(秒)
createdAt long true 作成日時
updatedAt long true 最終更新日時

Trigger

トリガー

相対時間イベントの開始時間を記録するトリガー

パラメータ データ型 必須 説明
triggerId string true トリガー
name string true トリガーの名前
userId string false ユーザーID
createdAt long true 作成日時
expiresAt long false トリガーの有効期限

Event

イベント

イベントの開催期間を定義します。 絶対期間・相対期間2種類の期間設定があり、相対期間はゲームプレイヤーによって開催中かどうかが異なります。

パラメータ データ型 必須 説明
eventId string true イベントマスター
name string true イベントの種類名
metadata string false イベントの種類のメタデータ
scheduleType string true イベント期間の種類
repeatType string true 繰り返しの種類
absoluteBegin long true イベントの開始日時
absoluteEnd long true イベントの終了日時
repeatBeginDayOfMonth integer true イベントの繰り返し開始日
repeatEndDayOfMonth integer true イベントの繰り返し終了日
repeatBeginDayOfWeek string true イベントの繰り返し開始曜日
repeatEndDayOfWeek string true イベントの繰り返し終了曜日
repeatBeginHour integer true イベントの繰り返し開始時間
repeatEndHour integer true イベントの繰り返し終了時間
relativeTriggerName string true イベントの開始トリガー
relativeDuration integer true イベントの開催期間(秒)

CurrentEventMaster

現在有効なイベントスケジュールマスター

エクスポートしたマスターデータを、現在有効なイベントスケジュールマスターとしてインポートして使用します。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
settings string true マスターデータ

ResponseCache

レスポンスキャッシュ

パラメータ データ型 必須 説明
region string false
ownerId string true オーナーID
responseCacheId string true レスポンスキャッシュ のGRN
requestHash string false
result string true APIの応答内容

GitHubCheckoutSetting

GitHubからリソースをチェックアウトしてくる設定

パラメータ データ型 必須 説明
apiKeyId string true リソースの取得に使用するGitHub のAPIキー のGRN
repositoryName string true リポジトリ名
sourcePath string true ソースコードのファイルパス
referenceType string true コードの取得元
commitHash string true コミットハッシュ
branchName string true ブランチ名
tagName string true タグ名

LogSetting

ロギング通知設定

パラメータ データ型 必須 説明
loggingNamespaceId string false ログの記録に使用する GS2-Log のネームスペース のGRN

初期化処理

HTTPプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_schedule_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2ScheduleRestClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.schedule.rest.Gs2ScheduleRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)
session.connect()
Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session)
初期化処理は不要です

HTTPプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_schedule_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2ScheduleRestClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.schedule.rest.Gs2ScheduleRestClient

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

session.connect_async(
    (result) => {
        Gs2ScheduleRestClient client = new Gs2ScheduleRestClient(session)
    }
)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_schedule_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2ScheduleWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.schedule.webSocket.Gs2ScheduleWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect()
Gs2ScheduleWebSocketClient client = new Gs2ScheduleWebSocketClient(session)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_schedule_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2ScheduleWebSocketClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.schedule.webSocket.Gs2ScheduleWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2ScheduleWebSocketClient client = new Gs2ScheduleWebSocketClient(session)
    }
)
初期化処理は不要です

GS2-Schedule は HTTPプロトコル と WebSocketプロトコル の2種類のプロトコルをサポートしています。

HTTPプロトコル と WebSocketプロトコル の違いは以下に示すとおりです。

HTTP WebSocket
接続方式 都度接続 常時接続
応答性能 優れている
API制限 なし 大容量のデータをやりとりするAPIには使用不可(主にマスターデータ系処理)
利用料金 WebSocketと同一 HTTPと同一

終了処理

HTTPプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

WebSocketプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

session オブジェクトの切断処理を行って終了処理を行います。 同一 session オブジェクトを複数の異なる Client オブジェクトに渡すことができます。

メソッド

createEventMaster

同期処理

from gs2_schedule_client.request import CreateEventMasterRequest
from gs2_schedule_client.result import CreateEventMasterResult

result = client.create_event_master(
    CreateEventMasterRequest()\
        .with_namespace_name('schedule-0001')\
        .with_name('event-0001')\
        .with_schedule_type('absolute')\
        .with_absolute_begin(10000)\
        .with_absolute_end(20000)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.CreateEventMasterRequest
import io.gs2.schedule.result.CreateEventMasterResult

result = client.createEventMaster(
    CreateEventMasterRequest()
        .withNamespaceName("schedule-0001")
        .withName("event-0001")
        .withScheduleType("absolute")
        .withAbsoluteBegin(10000l)
        .withAbsoluteEnd(20000l)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import CreateEventMasterRequest
from gs2_schedule_client.result import CreateEventMasterResult

def callback(async_result: AsyncResult[CreateEventMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_event_master_async(
    CreateEventMasterRequest()\
        .with_namespace_name('schedule-0001')\
        .with_name('event-0001')\
        .with_schedule_type('absolute')\
        .with_absolute_begin(10000)\
        .with_absolute_end(20000),
    callback
)
import io.gs2.schedule.request.CreateEventMasterRequest
import io.gs2.schedule.result.CreateEventMasterResult

result = client.createEventMaster(
    CreateEventMasterRequest()
        .withNamespaceName("schedule-0001")
        .withName("event-0001")
        .withScheduleType("absolute")
        .withAbsoluteBegin(10000l)
        .withAbsoluteEnd(20000l),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Schedule::EventMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  ScheduleType: String
  AbsoluteBegin: Long
  AbsoluteEnd: Long
  RepeatType: String
  RepeatBeginDayOfMonth: Integer
  RepeatEndDayOfMonth: Integer
  RepeatBeginDayOfWeek: String
  RepeatEndDayOfWeek: String
  RepeatBeginHour: Integer
  RepeatEndHour: Integer
  RelativeTriggerName: String
  RelativeDuration: Integer

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true イベントの種類名
description string false イベントマスターの説明
metadata string false イベントの種類のメタデータ
scheduleType string true イベント期間の種類
absoluteBegin long true イベントの開始日時
absoluteEnd long true イベントの終了日時
repeatType string true 繰り返しの種類
repeatBeginDayOfMonth integer true イベントの繰り返し開始日
repeatEndDayOfMonth integer true イベントの繰り返し終了日
repeatBeginDayOfWeek string true イベントの繰り返し開始曜日
repeatEndDayOfWeek string true イベントの繰り返し終了曜日
repeatBeginHour integer true イベントの繰り返し開始時間
repeatEndHour integer true イベントの繰り返し終了時間
relativeTriggerName string true イベントの開始トリガー名
relativeDuration integer true イベントの開催期間(秒)
パラメータ データ型 説明
item EventMaster 作成したイベントマスター

createNamespace

同期処理

from gs2_schedule_client.request import CreateNamespaceRequest
from gs2_schedule_client.result import CreateNamespaceResult

result = client.create_namespace(
    CreateNamespaceRequest()\
        .with_name('schedule-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.CreateNamespaceRequest
import io.gs2.schedule.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("schedule-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import CreateNamespaceRequest
from gs2_schedule_client.result import CreateNamespaceResult

def callback(async_result: AsyncResult[CreateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_namespace_async(
    CreateNamespaceRequest()\
        .with_name('schedule-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.schedule.request.CreateNamespaceRequest
import io.gs2.schedule.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("schedule-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Schedule::Namespace
Properties:
  Name: String
  Description: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

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

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false ネームスペースの説明
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

deleteEventMaster

同期処理

from gs2_schedule_client.request import DeleteEventMasterRequest
from gs2_schedule_client.result import DeleteEventMasterResult

result = client.delete_event_master(
    DeleteEventMasterRequest()\
        .with_namespace_name('schedule-0001')\
        .with_event_name('event-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DeleteEventMasterRequest
import io.gs2.schedule.result.DeleteEventMasterResult

result = client.deleteEventMaster(
    DeleteEventMasterRequest()
        .withNamespaceName("schedule-0001")
        .withEventName("event-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DeleteEventMasterRequest
from gs2_schedule_client.result import DeleteEventMasterResult

def callback(async_result: AsyncResult[DeleteEventMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_event_master_async(
    DeleteEventMasterRequest()\
        .with_namespace_name('schedule-0001')\
        .with_event_name('event-0001'),
    callback
)
import io.gs2.schedule.request.DeleteEventMasterRequest
import io.gs2.schedule.result.DeleteEventMasterResult

result = client.deleteEventMaster(
    DeleteEventMasterRequest()
        .withNamespaceName("schedule-0001")
        .withEventName("event-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

イベントマスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
eventName string true イベントの種類名
パラメータ データ型 説明
item EventMaster 削除したイベントマスター

deleteNamespace

同期処理

from gs2_schedule_client.request import DeleteNamespaceRequest
from gs2_schedule_client.result import DeleteNamespaceResult

result = client.delete_namespace(
    DeleteNamespaceRequest()\
        .with_namespace_name('schedule-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DeleteNamespaceRequest
import io.gs2.schedule.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("schedule-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DeleteNamespaceRequest
from gs2_schedule_client.result import DeleteNamespaceResult

def callback(async_result: AsyncResult[DeleteNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_namespace_async(
    DeleteNamespaceRequest()\
        .with_namespace_name('schedule-0001'),
    callback
)
import io.gs2.schedule.request.DeleteNamespaceRequest
import io.gs2.schedule.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("schedule-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace 削除したネームスペース

deleteTrigger

同期処理

from gs2_schedule_client.request import DeleteTriggerRequest
from gs2_schedule_client.result import DeleteTriggerResult

result = client.delete_trigger(
    DeleteTriggerRequest()\
        .with_namespace_name('schedule-0002')\
        .with_trigger_name('trigger1')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DeleteTriggerRequest
import io.gs2.schedule.result.DeleteTriggerResult

result = client.deleteTrigger(
    DeleteTriggerRequest()
        .withNamespaceName("schedule-0002")
        .withTriggerName("trigger1")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DeleteTriggerRequest
from gs2_schedule_client.result import DeleteTriggerResult

def callback(async_result: AsyncResult[DeleteTriggerResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_trigger_async(
    DeleteTriggerRequest()\
        .with_namespace_name('schedule-0002')\
        .with_trigger_name('trigger1'),
    callback
)
import io.gs2.schedule.request.DeleteTriggerRequest
import io.gs2.schedule.result.DeleteTriggerResult

result = client.deleteTrigger(
    DeleteTriggerRequest()
        .withNamespaceName("schedule-0002")
        .withTriggerName("trigger1"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

トリガーを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
triggerName string true トリガーの名前
パラメータ データ型 説明
item Trigger トリガー

deleteTriggerByUserId

同期処理

from gs2_schedule_client.request import DeleteTriggerByUserIdRequest
from gs2_schedule_client.result import DeleteTriggerByUserIdResult

result = client.delete_trigger_by_user_id(
    DeleteTriggerByUserIdRequest()\
        .with_namespace_name('schedule-0001')\
        .with_user_id('user-0001')\
        .with_trigger_name('trigger3')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DeleteTriggerByUserIdRequest
import io.gs2.schedule.result.DeleteTriggerByUserIdResult

result = client.deleteTriggerByUserId(
    DeleteTriggerByUserIdRequest()
        .withNamespaceName("schedule-0001")
        .withUserId("user-0001")
        .withTriggerName("trigger3")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DeleteTriggerByUserIdRequest
from gs2_schedule_client.result import DeleteTriggerByUserIdResult

def callback(async_result: AsyncResult[DeleteTriggerByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_trigger_by_user_id_async(
    DeleteTriggerByUserIdRequest()\
        .with_namespace_name('schedule-0001')\
        .with_user_id('user-0001')\
        .with_trigger_name('trigger3'),
    callback
)
import io.gs2.schedule.request.DeleteTriggerByUserIdRequest
import io.gs2.schedule.result.DeleteTriggerByUserIdResult

result = client.deleteTriggerByUserId(
    DeleteTriggerByUserIdRequest()
        .withNamespaceName("schedule-0001")
        .withUserId("user-0001")
        .withTriggerName("trigger3"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
triggerName string true トリガーの名前
パラメータ データ型 説明
item Trigger トリガー

describeEventMasters

同期処理

from gs2_schedule_client.request import DescribeEventMastersRequest
from gs2_schedule_client.result import DescribeEventMastersResult

result = client.describe_event_masters(
    DescribeEventMastersRequest()\
        .with_namespace_name('schedule-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DescribeEventMastersRequest
import io.gs2.schedule.result.DescribeEventMastersResult

result = client.describeEventMasters(
    DescribeEventMastersRequest()
        .withNamespaceName("schedule-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DescribeEventMastersRequest
from gs2_schedule_client.result import DescribeEventMastersResult

def callback(async_result: AsyncResult[DescribeEventMastersResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_event_masters_async(
    DescribeEventMastersRequest()\
        .with_namespace_name('schedule-0001'),
    callback
)
import io.gs2.schedule.request.DescribeEventMastersRequest
import io.gs2.schedule.result.DescribeEventMastersResult

result = client.describeEventMasters(
    DescribeEventMastersRequest()
        .withNamespaceName("schedule-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[EventMaster] イベントマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeEvents

同期処理

from gs2_schedule_client.request import DescribeEventsRequest
from gs2_schedule_client.result import DescribeEventsResult

result = client.describe_events(
    DescribeEventsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DescribeEventsRequest
import io.gs2.schedule.result.DescribeEventsResult

result = client.describeEvents(
    DescribeEventsRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DescribeEventsRequest
from gs2_schedule_client.result import DescribeEventsResult

def callback(async_result: AsyncResult[DescribeEventsResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_events_async(
    DescribeEventsRequest()\
    callback
)
import io.gs2.schedule.request.DescribeEventsRequest
import io.gs2.schedule.result.DescribeEventsResult

result = client.describeEvents(
    DescribeEventsRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

イベントの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[Event] イベントのリスト

describeEventsByUserId

同期処理

from gs2_schedule_client.request import DescribeEventsByUserIdRequest
from gs2_schedule_client.result import DescribeEventsByUserIdResult

result = client.describe_events_by_user_id(
    DescribeEventsByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DescribeEventsByUserIdRequest
import io.gs2.schedule.result.DescribeEventsByUserIdResult

result = client.describeEventsByUserId(
    DescribeEventsByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DescribeEventsByUserIdRequest
from gs2_schedule_client.result import DescribeEventsByUserIdResult

def callback(async_result: AsyncResult[DescribeEventsByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_events_by_user_id_async(
    DescribeEventsByUserIdRequest()\
    callback
)
import io.gs2.schedule.request.DescribeEventsByUserIdRequest
import io.gs2.schedule.result.DescribeEventsByUserIdResult

result = client.describeEventsByUserId(
    DescribeEventsByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してイベントの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
パラメータ データ型 説明
items list[Event] イベントのリスト

describeNamespaces

同期処理

from gs2_schedule_client.request import DescribeNamespacesRequest
from gs2_schedule_client.result import DescribeNamespacesResult

result = client.describe_namespaces(
    DescribeNamespacesRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DescribeNamespacesRequest
import io.gs2.schedule.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DescribeNamespacesRequest
from gs2_schedule_client.result import DescribeNamespacesResult

def callback(async_result: AsyncResult[DescribeNamespacesResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_namespaces_async(
    DescribeNamespacesRequest()\
    callback
)
import io.gs2.schedule.request.DescribeNamespacesRequest
import io.gs2.schedule.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Namespace] ネームスペースのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeRawEvents

同期処理

from gs2_schedule_client.request import DescribeRawEventsRequest
from gs2_schedule_client.result import DescribeRawEventsResult

result = client.describe_raw_events(
    DescribeRawEventsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DescribeRawEventsRequest
import io.gs2.schedule.result.DescribeRawEventsResult

result = client.describeRawEvents(
    DescribeRawEventsRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DescribeRawEventsRequest
from gs2_schedule_client.result import DescribeRawEventsResult

def callback(async_result: AsyncResult[DescribeRawEventsResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_raw_events_async(
    DescribeRawEventsRequest()\
    callback
)
import io.gs2.schedule.request.DescribeRawEventsRequest
import io.gs2.schedule.result.DescribeRawEventsResult

result = client.describeRawEvents(
    DescribeRawEventsRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

イベントの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[Event] イベントのリスト

describeTriggers

同期処理

from gs2_schedule_client.request import DescribeTriggersRequest
from gs2_schedule_client.result import DescribeTriggersResult

result = client.describe_triggers(
    DescribeTriggersRequest()\
        .with_namespace_name('schedule-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DescribeTriggersRequest
import io.gs2.schedule.result.DescribeTriggersResult

result = client.describeTriggers(
    DescribeTriggersRequest()
        .withNamespaceName("schedule-0002")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DescribeTriggersRequest
from gs2_schedule_client.result import DescribeTriggersResult

def callback(async_result: AsyncResult[DescribeTriggersResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_triggers_async(
    DescribeTriggersRequest()\
        .with_namespace_name('schedule-0002'),
    callback
)
import io.gs2.schedule.request.DescribeTriggersRequest
import io.gs2.schedule.result.DescribeTriggersResult

result = client.describeTriggers(
    DescribeTriggersRequest()
        .withNamespaceName("schedule-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

トリガーの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Trigger] トリガーのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeTriggersByUserId

同期処理

from gs2_schedule_client.request import DescribeTriggersByUserIdRequest
from gs2_schedule_client.result import DescribeTriggersByUserIdResult

result = client.describe_triggers_by_user_id(
    DescribeTriggersByUserIdRequest()\
        .with_namespace_name('schedule-0002')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.DescribeTriggersByUserIdRequest
import io.gs2.schedule.result.DescribeTriggersByUserIdResult

result = client.describeTriggersByUserId(
    DescribeTriggersByUserIdRequest()
        .withNamespaceName("schedule-0002")
        .withUserId("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import DescribeTriggersByUserIdRequest
from gs2_schedule_client.result import DescribeTriggersByUserIdResult

def callback(async_result: AsyncResult[DescribeTriggersByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_triggers_by_user_id_async(
    DescribeTriggersByUserIdRequest()\
        .with_namespace_name('schedule-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.schedule.request.DescribeTriggersByUserIdRequest
import io.gs2.schedule.result.DescribeTriggersByUserIdResult

result = client.describeTriggersByUserId(
    DescribeTriggersByUserIdRequest()
        .withNamespaceName("schedule-0002")
        .withUserId("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Trigger] トリガーのリスト
nextPageToken string リストの続きを取得するためのページトークン

exportMaster

同期処理

from gs2_schedule_client.request import ExportMasterRequest
from gs2_schedule_client.result import ExportMasterResult

result = client.export_master(
    ExportMasterRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.ExportMasterRequest
import io.gs2.schedule.result.ExportMasterResult

result = client.exportMaster(
    ExportMasterRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import ExportMasterRequest
from gs2_schedule_client.result import ExportMasterResult

def callback(async_result: AsyncResult[ExportMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.export_master_async(
    ExportMasterRequest()\
    callback
)
import io.gs2.schedule.request.ExportMasterRequest
import io.gs2.schedule.result.ExportMasterResult

result = client.exportMaster(
    ExportMasterRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

現在有効なイベントスケジュールマスターのマスターデータをエクスポートします

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentEventMaster 現在有効なイベントスケジュールマスター

getCurrentEventMaster

同期処理

from gs2_schedule_client.request import GetCurrentEventMasterRequest
from gs2_schedule_client.result import GetCurrentEventMasterResult

result = client.get_current_event_master(
    GetCurrentEventMasterRequest()\
        .with_namespace_name('schedule-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.GetCurrentEventMasterRequest
import io.gs2.schedule.result.GetCurrentEventMasterResult

result = client.getCurrentEventMaster(
    GetCurrentEventMasterRequest()
        .withNamespaceName("schedule-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import GetCurrentEventMasterRequest
from gs2_schedule_client.result import GetCurrentEventMasterResult

def callback(async_result: AsyncResult[GetCurrentEventMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_current_event_master_async(
    GetCurrentEventMasterRequest()\
        .with_namespace_name('schedule-0001'),
    callback
)
import io.gs2.schedule.request.GetCurrentEventMasterRequest
import io.gs2.schedule.result.GetCurrentEventMasterResult

result = client.getCurrentEventMaster(
    GetCurrentEventMasterRequest()
        .withNamespaceName("schedule-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

現在有効なイベントスケジュールマスターを取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentEventMaster 現在有効なイベントスケジュールマスター

getEvent

同期処理

from gs2_schedule_client.request import GetEventRequest
from gs2_schedule_client.result import GetEventResult

result = client.get_event(
    GetEventRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.GetEventRequest
import io.gs2.schedule.result.GetEventResult

result = client.getEvent(
    GetEventRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import GetEventRequest
from gs2_schedule_client.result import GetEventResult

def callback(async_result: AsyncResult[GetEventResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_event_async(
    GetEventRequest()\
    callback
)
import io.gs2.schedule.request.GetEventRequest
import io.gs2.schedule.result.GetEventResult

result = client.getEvent(
    GetEventRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

イベントを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
eventName string true イベントの種類名
パラメータ データ型 説明
item Event イベント

getEventByUserId

同期処理

from gs2_schedule_client.request import GetEventByUserIdRequest
from gs2_schedule_client.result import GetEventByUserIdResult

result = client.get_event_by_user_id(
    GetEventByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.GetEventByUserIdRequest
import io.gs2.schedule.result.GetEventByUserIdResult

result = client.getEventByUserId(
    GetEventByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import GetEventByUserIdRequest
from gs2_schedule_client.result import GetEventByUserIdResult

def callback(async_result: AsyncResult[GetEventByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_event_by_user_id_async(
    GetEventByUserIdRequest()\
    callback
)
import io.gs2.schedule.request.GetEventByUserIdRequest
import io.gs2.schedule.result.GetEventByUserIdResult

result = client.getEventByUserId(
    GetEventByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してイベントを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
eventName string true イベントの種類名
userId string true ユーザーID
パラメータ データ型 説明
item Event イベント

getEventMaster

同期処理

from gs2_schedule_client.request import GetEventMasterRequest
from gs2_schedule_client.result import GetEventMasterResult

result = client.get_event_master(
    GetEventMasterRequest()\
        .with_namespace_name('schedule-0001')\
        .with_event_name('event-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.GetEventMasterRequest
import io.gs2.schedule.result.GetEventMasterResult

result = client.getEventMaster(
    GetEventMasterRequest()
        .withNamespaceName("schedule-0001")
        .withEventName("event-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import GetEventMasterRequest
from gs2_schedule_client.result import GetEventMasterResult

def callback(async_result: AsyncResult[GetEventMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_event_master_async(
    GetEventMasterRequest()\
        .with_namespace_name('schedule-0001')\
        .with_event_name('event-0001'),
    callback
)
import io.gs2.schedule.request.GetEventMasterRequest
import io.gs2.schedule.result.GetEventMasterResult

result = client.getEventMaster(
    GetEventMasterRequest()
        .withNamespaceName("schedule-0001")
        .withEventName("event-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

イベントマスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
eventName string true イベントの種類名
パラメータ データ型 説明
item EventMaster イベントマスター

getNamespace

同期処理

from gs2_schedule_client.request import GetNamespaceRequest
from gs2_schedule_client.result import GetNamespaceResult

result = client.get_namespace(
    GetNamespaceRequest()\
        .with_namespace_name('schedule-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.GetNamespaceRequest
import io.gs2.schedule.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("schedule-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import GetNamespaceRequest
from gs2_schedule_client.result import GetNamespaceResult

def callback(async_result: AsyncResult[GetNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_async(
    GetNamespaceRequest()\
        .with_namespace_name('schedule-0001'),
    callback
)
import io.gs2.schedule.request.GetNamespaceRequest
import io.gs2.schedule.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("schedule-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace ネームスペース

getNamespaceStatus

同期処理

from gs2_schedule_client.request import GetNamespaceStatusRequest
from gs2_schedule_client.result import GetNamespaceStatusResult

result = client.get_namespace_status(
    GetNamespaceStatusRequest()\
        .with_namespace_name('schedule-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.GetNamespaceStatusRequest
import io.gs2.schedule.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest()
        .withNamespaceName("schedule-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import GetNamespaceStatusRequest
from gs2_schedule_client.result import GetNamespaceStatusResult

def callback(async_result: AsyncResult[GetNamespaceStatusResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_status_async(
    GetNamespaceStatusRequest()\
        .with_namespace_name('schedule-0001'),
    callback
)
import io.gs2.schedule.request.GetNamespaceStatusRequest
import io.gs2.schedule.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest()
        .withNamespaceName("schedule-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
status string

getRawEvent

同期処理

from gs2_schedule_client.request import GetRawEventRequest
from gs2_schedule_client.result import GetRawEventResult

result = client.get_raw_event(
    GetRawEventRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.GetRawEventRequest
import io.gs2.schedule.result.GetRawEventResult

result = client.getRawEvent(
    GetRawEventRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import GetRawEventRequest
from gs2_schedule_client.result import GetRawEventResult

def callback(async_result: AsyncResult[GetRawEventResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_raw_event_async(
    GetRawEventRequest()\
    callback
)
import io.gs2.schedule.request.GetRawEventRequest
import io.gs2.schedule.result.GetRawEventResult

result = client.getRawEvent(
    GetRawEventRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

イベントを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
eventName string true イベントの種類名
パラメータ データ型 説明
item Event イベント

getTrigger

同期処理

from gs2_schedule_client.request import GetTriggerRequest
from gs2_schedule_client.result import GetTriggerResult

result = client.get_trigger(
    GetTriggerRequest()\
        .with_namespace_name('schedule-0002')\
        .with_trigger_name('trigger1')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.GetTriggerRequest
import io.gs2.schedule.result.GetTriggerResult

result = client.getTrigger(
    GetTriggerRequest()
        .withNamespaceName("schedule-0002")
        .withTriggerName("trigger1")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import GetTriggerRequest
from gs2_schedule_client.result import GetTriggerResult

def callback(async_result: AsyncResult[GetTriggerResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_trigger_async(
    GetTriggerRequest()\
        .with_namespace_name('schedule-0002')\
        .with_trigger_name('trigger1'),
    callback
)
import io.gs2.schedule.request.GetTriggerRequest
import io.gs2.schedule.result.GetTriggerResult

result = client.getTrigger(
    GetTriggerRequest()
        .withNamespaceName("schedule-0002")
        .withTriggerName("trigger1"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

トリガーを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
triggerName string true トリガーの名前
パラメータ データ型 説明
item Trigger トリガー

getTriggerByUserId

同期処理

from gs2_schedule_client.request import GetTriggerByUserIdRequest
from gs2_schedule_client.result import GetTriggerByUserIdResult

result = client.get_trigger_by_user_id(
    GetTriggerByUserIdRequest()\
        .with_namespace_name('schedule-0001')\
        .with_user_id('user-0001')\
        .with_trigger_name('trigger3')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.GetTriggerByUserIdRequest
import io.gs2.schedule.result.GetTriggerByUserIdResult

result = client.getTriggerByUserId(
    GetTriggerByUserIdRequest()
        .withNamespaceName("schedule-0001")
        .withUserId("user-0001")
        .withTriggerName("trigger3")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import GetTriggerByUserIdRequest
from gs2_schedule_client.result import GetTriggerByUserIdResult

def callback(async_result: AsyncResult[GetTriggerByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_trigger_by_user_id_async(
    GetTriggerByUserIdRequest()\
        .with_namespace_name('schedule-0001')\
        .with_user_id('user-0001')\
        .with_trigger_name('trigger3'),
    callback
)
import io.gs2.schedule.request.GetTriggerByUserIdRequest
import io.gs2.schedule.result.GetTriggerByUserIdResult

result = client.getTriggerByUserId(
    GetTriggerByUserIdRequest()
        .withNamespaceName("schedule-0001")
        .withUserId("user-0001")
        .withTriggerName("trigger3"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
triggerName string true トリガーの名前
パラメータ データ型 説明
item Trigger トリガー

triggerByUserId

同期処理

from gs2_schedule_client.request import TriggerByUserIdRequest
from gs2_schedule_client.result import TriggerByUserIdResult

result = client.trigger_by_user_id(
    TriggerByUserIdRequest()\
        .with_namespace_name('schedule-0002')\
        .with_trigger_name('trigger1')\
        .with_user_id('user-0001')\
        .with_trigger_strategy('renew')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.TriggerByUserIdRequest
import io.gs2.schedule.result.TriggerByUserIdResult

result = client.triggerByUserId(
    TriggerByUserIdRequest()
        .withNamespaceName("schedule-0002")
        .withTriggerName("trigger1")
        .withUserId("user-0001")
        .withTriggerStrategy("renew")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import TriggerByUserIdRequest
from gs2_schedule_client.result import TriggerByUserIdResult

def callback(async_result: AsyncResult[TriggerByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.trigger_by_user_id_async(
    TriggerByUserIdRequest()\
        .with_namespace_name('schedule-0002')\
        .with_trigger_name('trigger1')\
        .with_user_id('user-0001')\
        .with_trigger_strategy('renew'),
    callback
)
import io.gs2.schedule.request.TriggerByUserIdRequest
import io.gs2.schedule.result.TriggerByUserIdResult

result = client.triggerByUserId(
    TriggerByUserIdRequest()
        .withNamespaceName("schedule-0002")
        .withTriggerName("trigger1")
        .withUserId("user-0001")
        .withTriggerStrategy("renew"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してトリガーを登録

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
triggerName string true トリガーの名前
userId string true ユーザーID
triggerStrategy string false トリガーの引き方の方針
ttl integer false トリガーの有効期限(秒)
パラメータ データ型 説明
item Trigger 引いたトリガー

updateCurrentEventMaster

同期処理

from gs2_schedule_client.request import UpdateCurrentEventMasterRequest
from gs2_schedule_client.result import UpdateCurrentEventMasterResult

result = client.update_current_event_master(
    UpdateCurrentEventMasterRequest()\
        .with_namespace_name('schedule-0001')\
        .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    },\n    {\n      "name": "event-0002",\n      "metadata": "EVENT_0002",\n      "scheduleType": "relative",\n      "relativeTriggerName": "trigger-0001",\n      "relativeDuration": 30000\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    },\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    },\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    },\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    },\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    },\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    }\n  ]\n}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.UpdateCurrentEventMasterRequest
import io.gs2.schedule.result.UpdateCurrentEventMasterResult

result = client.updateCurrentEventMaster(
    UpdateCurrentEventMasterRequest()
        .withNamespaceName("schedule-0001")
        .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    },\n    {\n      "name": "event-0002",\n      "metadata": "EVENT_0002",\n      "scheduleType": "relative",\n      "relativeTriggerName": "trigger-0001",\n      "relativeDuration": 30000\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    },\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    },\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    },\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    },\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    },\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    }\n  ]\n}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import UpdateCurrentEventMasterRequest
from gs2_schedule_client.result import UpdateCurrentEventMasterResult

def callback(async_result: AsyncResult[UpdateCurrentEventMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_current_event_master_async(
    UpdateCurrentEventMasterRequest()\
        .with_namespace_name('schedule-0001')\
        .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    },\n    {\n      "name": "event-0002",\n      "metadata": "EVENT_0002",\n      "scheduleType": "relative",\n      "relativeTriggerName": "trigger-0001",\n      "relativeDuration": 30000\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    },\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    },\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    },\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    },\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    },\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    }\n  ]\n}'),
    callback
)
import io.gs2.schedule.request.UpdateCurrentEventMasterRequest
import io.gs2.schedule.result.UpdateCurrentEventMasterResult

result = client.updateCurrentEventMaster(
    UpdateCurrentEventMasterRequest()
        .withNamespaceName("schedule-0001")
        .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    },\n    {\n      "name": "event-0002",\n      "metadata": "EVENT_0002",\n      "scheduleType": "relative",\n      "relativeTriggerName": "trigger-0001",\n      "relativeDuration": 30000\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    },\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    },\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    },\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    },\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    },\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    }\n  ]\n}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Schedule::CurrentEventMaster
Properties:
  NamespaceName: String
  Settings: String

現在有効なイベントスケジュールマスターを更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
settings string true マスターデータ
パラメータ データ型 説明
item CurrentEventMaster 更新した現在有効なイベントスケジュールマスター

updateCurrentEventMasterFromGitHub

同期処理

from gs2_schedule_client.request import UpdateCurrentEventMasterFromGitHubRequest
from gs2_schedule_client.result import UpdateCurrentEventMasterFromGitHubResult

result = client.update_current_event_master_from_git_hub(
    UpdateCurrentEventMasterFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.UpdateCurrentEventMasterFromGitHubRequest
import io.gs2.schedule.result.UpdateCurrentEventMasterFromGitHubResult

result = client.updateCurrentEventMasterFromGitHub(
    UpdateCurrentEventMasterFromGitHubRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import UpdateCurrentEventMasterFromGitHubRequest
from gs2_schedule_client.result import UpdateCurrentEventMasterFromGitHubResult

def callback(async_result: AsyncResult[UpdateCurrentEventMasterFromGitHubResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_current_event_master_from_git_hub_async(
    UpdateCurrentEventMasterFromGitHubRequest()\
    callback
)
import io.gs2.schedule.request.UpdateCurrentEventMasterFromGitHubRequest
import io.gs2.schedule.result.UpdateCurrentEventMasterFromGitHubResult

result = client.updateCurrentEventMasterFromGitHub(
    UpdateCurrentEventMasterFromGitHubRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

現在有効なイベントスケジュールマスターを更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
checkoutSetting GitHubCheckoutSetting true GitHubからマスターデータをチェックアウトしてくる設定
パラメータ データ型 説明
item CurrentEventMaster 更新した現在有効なイベントスケジュールマスター

updateEventMaster

同期処理

from gs2_schedule_client.request import UpdateEventMasterRequest
from gs2_schedule_client.result import UpdateEventMasterResult

result = client.update_event_master(
    UpdateEventMasterRequest()\
        .with_namespace_name('schedule-0001')\
        .with_event_name('event-0001')\
        .with_description('description1')\
        .with_metadata('{"hoge": "fuga"}')\
        .with_schedule_type('absolute')\
        .with_absolute_begin(10000)\
        .with_absolute_end(20000)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.UpdateEventMasterRequest
import io.gs2.schedule.result.UpdateEventMasterResult

result = client.updateEventMaster(
    UpdateEventMasterRequest()
        .withNamespaceName("schedule-0001")
        .withEventName("event-0001")
        .withDescription("description1")
        .withMetadata("{"hoge": "fuga"}")
        .withScheduleType("absolute")
        .withAbsoluteBegin(10000l)
        .withAbsoluteEnd(20000l)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import UpdateEventMasterRequest
from gs2_schedule_client.result import UpdateEventMasterResult

def callback(async_result: AsyncResult[UpdateEventMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_event_master_async(
    UpdateEventMasterRequest()\
        .with_namespace_name('schedule-0001')\
        .with_event_name('event-0001')\
        .with_description('description1')\
        .with_metadata('{"hoge": "fuga"}')\
        .with_schedule_type('absolute')\
        .with_absolute_begin(10000)\
        .with_absolute_end(20000),
    callback
)
import io.gs2.schedule.request.UpdateEventMasterRequest
import io.gs2.schedule.result.UpdateEventMasterResult

result = client.updateEventMaster(
    UpdateEventMasterRequest()
        .withNamespaceName("schedule-0001")
        .withEventName("event-0001")
        .withDescription("description1")
        .withMetadata("{"hoge": "fuga"}")
        .withScheduleType("absolute")
        .withAbsoluteBegin(10000l)
        .withAbsoluteEnd(20000l),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

イベントマスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
eventName string true イベントの種類名
description string false イベントマスターの説明
metadata string false イベントの種類のメタデータ
scheduleType string true イベント期間の種類
absoluteBegin long true イベントの開始日時
absoluteEnd long true イベントの終了日時
repeatType string true 繰り返しの種類
repeatBeginDayOfMonth integer true イベントの繰り返し開始日
repeatEndDayOfMonth integer true イベントの繰り返し終了日
repeatBeginDayOfWeek string true イベントの繰り返し開始曜日
repeatEndDayOfWeek string true イベントの繰り返し終了曜日
repeatBeginHour integer true イベントの繰り返し開始時間
repeatEndHour integer true イベントの繰り返し終了時間
relativeTriggerName string true イベントの開始トリガー名
relativeDuration integer true イベントの開催期間(秒)
パラメータ データ型 説明
item EventMaster 更新したイベントマスター

updateNamespace

同期処理

from gs2_schedule_client.request import UpdateNamespaceRequest
from gs2_schedule_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('schedule-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.schedule.request.UpdateNamespaceRequest
import io.gs2.schedule.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("schedule-0001")
        .withDescription("description1")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_schedule_client.request import UpdateNamespaceRequest
from gs2_schedule_client.result import UpdateNamespaceResult

def callback(async_result: AsyncResult[UpdateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_namespace_async(
    UpdateNamespaceRequest()\
        .with_namespace_name('schedule-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.schedule.request.UpdateNamespaceRequest
import io.gs2.schedule.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("schedule-0001")
        .withDescription("description1")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
description string false ネームスペースの説明
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

GS2-Script トリガーイベント

GS2-Schedule が提供するスクリプトトリガーはありません

マスターデータフォーマット

CurrentEventMaster

{
  "version": "2019-03-31"
  "events": [
    {
      "name": "[string] イベントの種類名",
      "metadata": "[string] イベントの種類のメタデータ",
      "scheduleType": "[string] イベント期間の種類",
      "repeatType": "[string] 繰り返しの種類",
      "absoluteBegin": "[long] イベントの開始日時",
      "absoluteEnd": "[long] イベントの終了日時",
      "repeatBeginDayOfMonth": "[integer] イベントの繰り返し開始日",
      "repeatEndDayOfMonth": "[integer] イベントの繰り返し終了日",
      "repeatBeginDayOfWeek": "[string] イベントの繰り返し開始曜日",
      "repeatEndDayOfWeek": "[string] イベントの繰り返し終了曜日",
      "repeatBeginHour": "[integer] イベントの繰り返し開始時間",
      "repeatEndHour": "[integer] イベントの繰り返し終了時間",
      "relativeTriggerName": "[string] イベントの開始トリガー",
      "relativeDuration": "[integer] イベントの開催期間(秒)"
    }
  ]
}

現在有効なイベントスケジュールマスター

エクスポートしたマスターデータを、現在有効なイベントスケジュールマスターとしてインポートして使用します。

GS2-Schedule の制限・制約

利用いただくにあたって注意いただく制限・制約はありません