> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Schedule SDK API 레퍼런스
각종 프로그래밍 언어용 GS2-Schedule SDK의 모델 사양과 API 레퍼런스
## 모델
### Namespace
네임스페이스
네임스페이스는 하나의 프로젝트 내에서 동일한 서비스를 서로 다른 용도로 여러 개 이용하기 위한 엔티티입니다.
GS2의 각 서비스는 네임스페이스 단위로 관리됩니다. 네임스페이스가 다르면 동일한 서비스라도 완전히 독립된 데이터 공간으로 취급됩니다.
따라서 각 서비스의 이용을 시작하려면 먼저 네임스페이스를 생성해야 합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024자 | 네임스페이스 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | 트랜잭션 설정
스케줄 작업 실행 시 트랜잭션 처리 방식을 제어하는 설정입니다. |
| logSetting | [LogSetting](#logsetting) | | | | | 로그 출력 설정
스케줄 관련 작업 로그를 GS2-Log로 출력하기 위한 설정입니다.
설정하면 이벤트 조회, 트리거 발동, 트리거 삭제 등의 작업이 분석 및 감사를 위해 기록됩니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeNamespaces - 네임스페이스 목록 조회
createNamespace - 네임스페이스 신규 생성
getNamespace - 네임스페이스 조회
updateNamespace - 네임스페이스 갱신
deleteNamespace - 네임스페이스 삭제
---
### TransactionSetting
트랜잭션 설정
트랜잭션 설정은 트랜잭션의 실행 방법·정합성·비동기 처리·충돌 회피 메커니즘을 제어하는 설정입니다.
자동 실행(AutoRun), 원자적 실행(AtomicCommit), GS2-Distributor를 이용한 비동기 실행, 스크립트 결과의 일괄 적용, GS2-JobQueue를 통한 입수 액션의 비동기화 등을 조합하여 게임 로직에 맞는 견고한 트랜잭션 관리를 가능하게 합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| enableAutoRun | bool | | | false | | 발행한 트랜잭션을 서버 사이드에서 자동으로 실행할지 여부 |
| enableAtomicCommit | bool | {enableAutoRun} == true | | false | | 트랜잭션의 실행을 원자적으로 커밋할지 여부
※ enableAutoRun이(가) true 이면 활성화 |
| transactionUseDistributor | bool | {enableAtomicCommit} == true | | false | | 트랜잭션을 비동기 처리로 실행할지 여부
※ enableAtomicCommit이(가) true 이면 활성화 |
| commitScriptResultInUseDistributor | bool | {transactionUseDistributor} == true | | false | | 스크립트의 결과 커밋 처리를 비동기 처리로 실행할지 여부
※ transactionUseDistributor이(가) true 이면 활성화 |
| acquireActionUseJobQueue | bool | {enableAtomicCommit} == true | | false | | 입수 액션을 실행할 때 GS2-JobQueue를 사용할지 여부
※ enableAtomicCommit이(가) true 이면 활성화 |
| distributorNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:distributor:default" | ~ 1024자 | 트랜잭션 실행에 사용하는 GS2-Distributor 네임스페이스GRN |
| queueNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:queue:default" | ~ 1024자 | 트랜잭션 실행에 사용하는 GS2-JobQueue의 네임스페이스GRN |
**관련 메서드:**
createNamespace - 네임스페이스 신규 생성
updateNamespace - 네임스페이스 갱신
**관련 모델:**
Namespace - 네임스페이스
---
### LogSetting
로그 출력 설정
로그 데이터의 출력 설정을 관리합니다. 이 타입은 로그 데이터를 출력하기 위해 사용되는 GS2-Log 네임스페이스의 식별자(Namespace ID)를 보관합니다.
로그 네임스페이스ID(loggingNamespaceId)에는 로그 데이터를 수집하여 저장하는 GS2-Log의 네임스페이스를 GRN 형식으로 지정합니다.
이 설정을 하면 설정된 네임스페이스 내에서 발생한 API 요청·응답 로그 데이터가 대상 GS2-Log 네임스페이스 쪽으로 출력됩니다.
GS2-Log에서는 실시간으로 로그가 제공되어 시스템 모니터링, 분석, 디버깅 등에 활용할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| loggingNamespaceId | string | | ✓ | | ~ 1024자 | 로그를 출력할 GS2-Log의 네임스페이스GRN
"grn:gs2:"로 시작하는 GRN 형식의 ID로 지정해야 합니다. |
**관련 메서드:**
createNamespace - 네임스페이스 신규 생성
updateNamespace - 네임스페이스 갱신
**관련 모델:**
Namespace - 네임스페이스
---
### GitHubCheckoutSetting
GitHub에서 마스터 데이터를 체크아웃하는 설정
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| apiKeyId | string | | ✓ | | ~ 1024자 | GitHub API 키의 GRN |
| repositoryName | string | | ✓ | | ~ 1024자 | 리포지토리 이름 |
| sourcePath | string | | ✓ | | ~ 1024자 | 마스터 데이터(JSON) 파일 경로 |
| referenceType | 문자열 열거형
enum {
"commit_hash",
"branch",
"tag"
}
| | ✓ | | | 코드 출처commit_hash: 커밋 해시 / branch: 브랜치 / tag: 태그 / |
| commitHash | string | {referenceType} == "commit_hash" | ✓※ | | ~ 1024자 | 커밋 해시
※ referenceType이(가) "commit_hash" 이면 필수 |
| branchName | string | {referenceType} == "branch" | ✓※ | | ~ 1024자 | 브랜치 이름
※ referenceType이(가) "branch" 이면 필수 |
| tagName | string | {referenceType} == "tag" | ✓※ | | ~ 1024자 | 태그 이름
※ referenceType이(가) "tag" 이면 필수 |
**관련 메서드:**
updateCurrentEventMasterFromGitHub - 현재 활성화된 이벤트의 마스터 데이터를 GitHub에서 업데이트
---
### Trigger
트리거
상대 이벤트 스케줄링의 기점을 정의하여, 플레이어별 이벤트 기간을 구현합니다.
플레이어에 대해 트리거가 발동되면 발동 시각(triggeredAt)과 유효 기간(expiresAt)이 기록됩니다.
"relative" 스케줄 타입으로 설정된 이벤트는 트리거를 이름으로 참조하며, 해당 플레이어의 이벤트 기간은 트리거의 발동 시각부터 유효 기간까지 이어집니다.
트리거는 갱신할 수 있으며(createdAt을 재설정하고 expiresAt을 업데이트), 유효 기간이 지나면 TTL에 의해 자동으로 정리됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| triggerId | string | | ※ | | ~ 1024자 | 트리거 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 트리거 이름
트리거 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| triggeredAt | long | | ※ | 현재 시각 | | 트리거 발동 일시
이 트리거가 발동된 타임스탬프입니다.
상대 이벤트 스케줄링의 기준 시작점 역할을 합니다. 명시적으로 지정하지 않으면 현재 시각이 자동으로 설정됩니다.
UNIX 시간(밀리초)으로 표현됩니다. |
| expiresAt | long | | ✓ | | | 유효 기간
이 트리거가 만료되어 상대 이벤트 기간이 종료되는 타임스탬프입니다.
이 시각 이후 트리거는 만료된 것으로 간주되며(IsExpire가 true를 반환), 해당 플레이어에 대한 관련 상대 이벤트는 더 이상 유효하지 않습니다.
트리거 데이터는 만료 후 DynamoDB TTL에 의해 자동으로 정리됩니다. UNIX 시간(밀리초)으로 표현됩니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeTriggers - 트리거 목록 취득
describeTriggersByUserId - 사용자 ID를 지정하여 트리거 목록 취득
getTrigger - 트리거 취득
getTriggerByUserId - 사용자 ID를 지정하여 트리거 취득
triggerByUserId - 사용자 ID를 지정하여 트리거 실행
extendTriggerByUserId - 사용자 ID를 지정하여 트리거 기간 연장
deleteTrigger - 트리거 삭제
deleteTriggerByUserId - 사용자 ID를 지정하여 트리거 삭제
verifyTrigger - 트리거가 당겨진 후 경과 시간 검증
verifyTriggerByUserId - 사용자 ID를 지정하여 트리거가 당겨진 후 경과 시간 검증
---
### Event
이벤트
이벤트의 기간에는 절대 기간과 상대 기간의 2가지 종류가 있습니다.
절대 기간은 예를 들어 YYYY년 MM월 DD일 00:00(UTC) ~ YYYY년 MM월 DD일 23:59(UTC)와 같은 고정된 기간이며,
상대 기간은 트리거를 당긴 시점부터 24시간과 같이 게임 플레이어마다 다른 기간을 이벤트 기간으로 하는 것입니다.
이벤트에는 개최 기간뿐만 아니라 반복도 설정할 수 있게 되어 있어
이벤트 기간 중 월요일 10:00 ~ 11:00만을 이벤트 기간으로 하는 설정도 가능합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| eventId | string | | ※ | | ~ 1024자 | GS2-Schedule 이벤트 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 이벤트 이름
이벤트 고유의 이름. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| scheduleType | 문자열 열거형
enum {
"absolute",
"relative"
}
| | ✓ | | | 스케줄 타입
이벤트 기간을 정의하는 방식을 결정합니다.
"absolute"는 모든 플레이어에게 동일하게 적용되는 고정된 시작/종료 타임스탬프를 사용합니다.
"relative"는 플레이어별 트리거를 기점으로 사용하여, 개인화된 이벤트 기간을 구현합니다(예: 각 플레이어가 처음 로그인한 시점부터 24시간).absolute: 고정 기간 / relative: 플레이어별 기간 / |
| absoluteBegin | long | | | | | 절대 시작 일시
절대 스케줄링에서 이벤트 기간의 고정 시작 시각입니다.
모든 플레이어가 동일한 시작 시각을 공유합니다. 절대 이벤트에서 설정하지 않으면 이벤트는 과거부터 시작된 것으로 취급됩니다.
UNIX 시간(밀리초)으로 표현됩니다. |
| absoluteEnd | long | | | | | 절대 종료 일시
절대 스케줄링에서 이벤트 기간의 고정 종료 시각입니다.
모든 플레이어가 동일한 종료 시각을 공유합니다. 절대 이벤트에서 설정하지 않으면 이벤트는 종료되지 않는 것으로 취급됩니다.
UNIX 시간(밀리초)으로 표현됩니다. |
| relativeTriggerName | string | {scheduleType} == "relative" | ✓※ | | ~ 128자 | 이벤트 시작 트리거 이름
게임 플레이어별로 이벤트 기간을 설정하는(`relative`) 경우, 이벤트 시작의 기점이 되는 트리거의 이름을 지정합니다.
영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다.
※ scheduleType이(가) "relative" 이면 필수 |
| repeatSetting | [RepeatSetting](#repeatsetting) | | ✓ | | | 반복 설정
이벤트 기간 내에서 반복되는 유효 시간대에 대한 설정입니다.
활성 기간을 특정 시간대, 요일, 월중 날짜, 또는 사용자 지정 활성/비활성 일 주기로 좁힐 수 있습니다.
반복 패턴 없이 이벤트 기간 전체를 활성 상태로 유지하려면 repeatType을 "always"로 설정합니다. |
**관련 메서드:**
describeEvents - 이벤트 목록 조회
describeEventsByUserId - 사용자 ID를 지정하여 이벤트 목록 조회
describeRawEvents - 이벤트 목록 조회
getEvent - 이벤트 조회
getEventByUserId - 사용자 ID를 지정하여 이벤트 조회
getRawEvent - 이벤트 조회
verifyEvent - 이벤트 개최 기간인지 검증
verifyEventByUserId - 사용자 ID를 지정하여 이벤트 개최 기간인지 검증
---
### RepeatSetting
반복 설정
이벤트 전체 기간 내에서 반복되는 유효 시간대를 설정합니다.
5가지 반복 타입을 지원합니다: "always"(이벤트 기간 전체), "daily"(매일 특정 시간대), "weekly"(매주 특정 요일 범위+시간대),
"monthly"(매월 특정 날짜 범위+시간대), "custom"(기준일로부터 활성/비활성 일수의 교대 주기).
daily/weekly/monthly 타입에서 beginHour와 endHour가 같으면 종료 시각은 다음 날 같은 시각으로 처리됩니다(즉 24시간 전체 윈도우).
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| repeatType | 문자열 열거형
enum {
"always",
"daily",
"weekly",
"monthly",
"custom"
}
| | | "always" | | 반복 종류
이벤트 기간 내에 적용할 반복 패턴의 종류입니다.
타입에 따라 필요한 추가 필드가 다릅니다: daily/weekly/monthly는 시간 설정, weekly는 요일, monthly는 날짜, custom은 기준 타임스탬프와 일수가 필요합니다.
지정하지 않으면 기본값은 "always"입니다.always: 이벤트 기간 중 상시 유효 / daily: 이벤트 기간 중 매일 X시~X시 / weekly: 이벤트 기간 중 매주 개시 요일~종료 요일 X시~X시 / monthly: 이벤트 기간 중 매월 개시일~종료일 X시~X시 / custom: 기준일부터 시작하여, 이벤트 기간 중 X일 활성, Y일 비활성을 반복 / |
| beginDayOfMonth | int | {repeatType} == "monthly" | ✓※ | | 1 ~ 31 | 반복 시작일
반복 윈도우가 시작되는 월중 날짜(1~31)입니다.
지정한 값이 해당 월의 일수를 초과하는 경우, 해당 월의 마지막 날로 처리됩니다.
repeatType이 "monthly"인 경우에만 적용됩니다.
※ repeatType이(가) "monthly" 이면 필수 |
| endDayOfMonth | int | {repeatType} == "monthly" | ✓※ | | 1 ~ 31 | 반복 종료일
반복 윈도우가 종료되는 월중 날짜(1~31)입니다.
지정한 값이 해당 월의 일수를 초과하는 경우, 해당 월의 마지막 날로 처리됩니다.
repeatType이 "monthly"인 경우에만 적용됩니다.
※ repeatType이(가) "monthly" 이면 필수 |
| beginDayOfWeek | 문자열 열거형
enum {
"sunday",
"monday",
"tuesday",
"wednesday",
"thursday",
"friday",
"saturday"
}
| {repeatType} == "weekly" | ✓※ | | | 반복 시작 요일
반복 윈도우가 시작되는 요일입니다.
윈도우는 주의 경계를 넘어설 수 있습니다(예: 금요일~월요일). repeatType이 "weekly"인 경우에만 적용됩니다.sunday: 일요일 / monday: 월요일 / tuesday: 화요일 / wednesday: 수요일 / thursday: 목요일 / friday: 금요일 / saturday: 토요일 /
※ repeatType이(가) "weekly" 이면 필수 |
| endDayOfWeek | 문자열 열거형
enum {
"sunday",
"monday",
"tuesday",
"wednesday",
"thursday",
"friday",
"saturday"
}
| {repeatType} == "weekly" | ✓※ | | | 반복 종료 요일
반복 윈도우가 종료되는 요일입니다.
beginDayOfWeek과 조합하여 주간 활성 기간을 정의합니다. repeatType이 "weekly"인 경우에만 적용됩니다.sunday: 일요일 / monday: 월요일 / tuesday: 화요일 / wednesday: 수요일 / thursday: 목요일 / friday: 금요일 / saturday: 토요일 /
※ repeatType이(가) "weekly" 이면 필수 |
| beginHour | int | {repeatType} in ["daily", "weekly", "monthly"] | ✓※ | | 0 ~ 23 | 반복 시작 시각(시)
각 주기마다 반복 윈도우가 시작되는 시각(UTC, 0~23)입니다.
daily, weekly, monthly 반복 타입에서 필수입니다. beginHour와 endHour가 같으면 윈도우는 24시간(다음 날 같은 시각까지)이 됩니다.
※ repeatType이(가) "daily","weekly","monthly"이면 필수 |
| endHour | int | {repeatType} in ["daily", "weekly", "monthly"] | ✓※ | | 0 ~ 24 | 반복 종료 시각(시)
각 주기마다 반복 윈도우가 종료되는 시각(UTC, 0~24)입니다.
24를 지정하면 다음 날 자정을 나타냅니다. daily, weekly, monthly 반복 타입에서 필수입니다.
※ repeatType이(가) "daily","weekly","monthly"이면 필수 |
| anchorTimestamp | long | {repeatType} == "custom" | ✓※ | | | 기준 타임스탬프
커스텀 활성/비활성 주기가 시작되는 기준일입니다.
시스템은 이 기준일로부터 경과한 일수를 바탕으로 현재 시각이 어느 단계(활성 또는 비활성)에 있는지 계산합니다.
repeatType이 "custom"인 경우에만 적용됩니다. UNIX 시간(밀리초)으로 표현합니다.
※ repeatType이(가) "custom" 이면 필수 |
| activeDays | int | {repeatType} == "custom" | ✓※ | | 1 ~ 2147483646 | 활성 일수
각 커스텀 주기에서 이벤트가 연속으로 활성 상태가 되는 일수입니다.
활성 일수가 지난 후, inactiveDays에서 지정한 일수만큼 이벤트가 비활성 상태가 되며, 이후 주기가 반복됩니다.
repeatType이 "custom"인 경우에만 적용됩니다. 최소 1일.
※ repeatType이(가) "custom" 이면 필수 |
| inactiveDays | int | {repeatType} == "custom" | ✓※ | | 0 ~ 2147483646 | 비활성 일수
각 커스텀 주기에서 이벤트가 연속으로 비활성 상태가 되는 일수입니다.
활성 일수 뒤에 이어집니다. 공백 없이 계속 활성 상태인 이벤트로 하려면 0을 설정합니다.
repeatType이 "custom"인 경우에만 적용됩니다. 최소 0일.
※ repeatType이(가) "custom" 이면 필수 |
**관련 메서드:**
createEventMaster - 이벤트 마스터 신규 생성
updateEventMaster - 이벤트 마스터 갱신
**관련 모델:**
Event - 이벤트
EventMaster - 이벤트 마스터
---
### RepeatSchedule
반복 스케줄 상태
특정 시점에서의 이벤트 반복 사이클의 현재 상태를 나타냅니다.
반복 횟수(사이클이 발생한 횟수), 현재 활성 윈도우의 시작·종료 시각,
전회 완료된 윈도우의 종료 시각, 그리고 다음 윈도우의 시작 시각을 포함합니다.
이 정보는 이벤트의 반복 설정과 현재 시각을 토대로 동적으로 계산됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| repeatCount | int | | ✓ | | 0 ~ 2147483646 | 반복 횟수
현재 시각까지 완료된 반복 사이클의 횟수.
반복 윈도우가 종료될 때마다 증가합니다. 시즌제나 정기 이벤트의 사이클 진행 상황을 추적하는 데 사용할 수 있습니다. |
| currentRepeatStartAt | long | | | | | 현재 반복 시작 일시
현재 활성 상태인 반복 윈도우의 시작 시각.
이벤트가 현재 활성 상태인 반복 윈도우에 있지 않은 경우 null 입니다. UNIX 시간(밀리초)으로 표현됩니다. |
| currentRepeatEndAt | long | | | | | 현재 반복 종료 일시
현재 활성 상태인 반복 윈도우의 종료 시각.
이벤트가 현재 활성 상태인 반복 윈도우에 있지 않은 경우 null 입니다. UNIX 시간(밀리초)으로 표현됩니다. |
| lastRepeatEndAt | long | | | | | 직전 반복 종료 일시
가장 최근에 완료된 반복 윈도우의 종료 시각.
아직 반복 윈도우가 종료되지 않은 경우 null 입니다. UNIX 시간(밀리초)으로 표현됩니다. |
| nextRepeatStartAt | long | | | | | 다음 반복 시작 일시
다음 반복 윈도우의 시작 시각.
이벤트 기간 내에 다음 반복 윈도우가 없는 경우 null 입니다. UNIX 시간(밀리초)으로 표현됩니다. |
**관련 메서드:**
getEvent - 이벤트 조회
getEventByUserId - 사용자 ID를 지정하여 이벤트 조회
verifyEvent - 이벤트 개최 기간인지 검증
verifyEventByUserId - 사용자 ID를 지정하여 이벤트 개최 기간인지 검증
---
### CurrentEventMaster
현재 활성화된 이벤트 마스터 데이터
현재 네임스페이스 내에서 유효한 이벤트 정의를 기술한 마스터 데이터입니다.
GS2에서는 마스터 데이터 관리에 JSON 형식 파일을 사용합니다.
파일을 업로드함으로써 실제로 서버에 설정을 반영할 수 있습니다.
JSON 파일을 작성하는 방법으로, 관리 콘솔 내에 마스터 데이터 에디터를 제공하고 있습니다.
또한 게임 운영에 더 적합한 도구를 직접 제작하여, 적절한 형식의 JSON 파일을 출력하는 방식으로도 서비스를 이용할 수 있습니다.
**ℹ️ Note**
JSON 파일 형식에 대해서는 [GS2-Schedule 마스터 데이터 레퍼런스](api_reference/schedule/master_data/)를 참조해 주세요.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024자 | 네임스페이스 GRN
※ 서버가 자동으로 설정 |
| settings | string | | ✓ | | ~ 5242880 바이트 (5MB) | 마스터 데이터 |
**관련 메서드:**
exportMaster - 모델 마스터를 활성화 가능한 마스터 데이터 형식으로 익스포트
getCurrentEventMaster - 현재 활성화된 이벤트의 마스터 데이터를 취득
updateCurrentEventMaster - 현재 활성화된 이벤트의 마스터 데이터를 업데이트
updateCurrentEventMasterFromGitHub - 현재 활성화된 이벤트의 마스터 데이터를 GitHub에서 업데이트
---
### EventMaster
이벤트 마스터
이벤트 마스터는 게임 내에서 사용되는 이벤트의 편집·관리용 데이터로, 관리 콘솔의 마스터 데이터 에디터에서 일시적으로 보관됩니다.
임포트·업데이트 처리를 수행하면 실제로 게임에서 참조되는 이벤트로 반영됩니다.
이벤트 기간에는 절대 기간과 상대 기간, 두 가지 종류가 있습니다.
절대 기간은 예를 들어 YYYY년 MM월 DD일 00:00(UTC) ~ YYYY년 MM월 DD일 23:59(UTC)와 같은 고정된 기간이며,
상대 기간은 트리거가 발동된 시점으로부터 24시간과 같이 게임 플레이어마다 다른 기간을 이벤트 기간으로 하는 것입니다.
이벤트에는 개최 기간뿐 아니라 반복도 설정할 수 있어
이벤트 기간 중 월요일 10:00 ~ 11:00만을 이벤트 기간으로 하는 설정도 가능합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| eventId | string | | ※ | | ~ 1024자 | 이벤트 마스터 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 이벤트 이름
이벤트 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| scheduleType | 문자열 열거형
enum {
"absolute",
"relative"
}
| | ✓ | | | 스케줄 타입
이벤트 기간을 정의하는 방식을 결정합니다.
"absolute"는 모든 플레이어에게 동일하게 적용되는 고정된 시작/종료 타임스탬프를 사용합니다.
"relative"는 플레이어별 트리거를 기점으로 사용하여, 개인화된 이벤트 기간을 구현합니다(예: 각 플레이어가 처음 로그인한 시점부터 24시간).absolute: 고정 기간 / relative: 플레이어별 기간 / |
| absoluteBegin | long | | | | | 절대 시작 일시
절대 스케줄링에서 이벤트 기간의 고정 시작 시각입니다.
모든 플레이어가 동일한 시작 시각을 공유합니다. 절대 이벤트에서 설정하지 않으면 이벤트는 과거부터 시작된 것으로 취급됩니다.
UNIX 시간(밀리초)으로 표현됩니다. |
| absoluteEnd | long | | | | | 절대 종료 일시
절대 스케줄링에서 이벤트 기간의 고정 종료 시각입니다.
모든 플레이어가 동일한 종료 시각을 공유합니다. 절대 이벤트에서 설정하지 않으면 이벤트는 종료되지 않는 것으로 취급됩니다.
UNIX 시간(밀리초)으로 표현됩니다. |
| relativeTriggerName | string | {scheduleType} == "relative" | ✓※ | | ~ 128자 | 이벤트 시작 트리거 이름
게임 플레이어별로 이벤트 기간을 설정하는(`relative`) 경우, 이벤트 시작의 기점이 되는 트리거의 이름을 지정합니다.
영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다.
※ scheduleType이(가) "relative" 이면 필수 |
| repeatSetting | [RepeatSetting](#repeatsetting) | | ✓ | | | 반복 설정
이벤트 기간 내에서 반복되는 유효 시간대에 대한 설정입니다.
활성 기간을 특정 시간대, 요일, 월중 날짜, 또는 사용자 지정 활성/비활성 일 주기로 좁힐 수 있습니다.
반복 패턴 없이 이벤트 기간 전체를 활성 상태로 유지하려면 repeatType을 "always"로 설정합니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeEventMasters - 이벤트 마스터 목록 조회
createEventMaster - 이벤트 마스터 신규 생성
getEventMaster - 이벤트 마스터 조회
updateEventMaster - 이벤트 마스터 갱신
deleteEventMaster - 이벤트 마스터 삭제
---
## 메서드
### describeNamespaces
네임스페이스 목록 조회
프로젝트 내에서 서비스 단위로 생성된 네임스페이스의 목록을 조회합니다.
옵션인 페이지 토큰을 사용하여 목록의 특정 위치부터 데이터 조회를 시작할 수 있습니다.
또한 조회할 네임스페이스의 수를 제한하는 것도 가능합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namePrefix | string | | | | ~ 64자 | 네임스페이스 이름의 필터 접두사 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Namespace>](#namespace) | 네임스페이스 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
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 {
NamePrefix: nil,
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->describeNamespaces(
(new DescribeNamespacesRequest())
->withNamePrefix(null)
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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()
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2Schedule.Request.DescribeNamespacesRequest()
.WithNamePrefix(null)
.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;
```
**TypeScript**
```typescript
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()
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
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_name_prefix(None)
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('schedule')
api_result = client.describe_namespaces({
namePrefix=nil,
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('schedule')
api_result_handler = client.describe_namespaces_async({
namePrefix=nil,
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createNamespace
네임스페이스 신규 생성
네임스페이스의 이름, 설명 및 각종 설정을 포함한 상세 정보를 지정해야 합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | 트랜잭션 설정
스케줄 작업 실행 시 트랜잭션 처리 방식을 제어하는 설정입니다. |
| logSetting | [LogSetting](#logsetting) | | | | | 로그 출력 설정
스케줄 관련 작업 로그를 GS2-Log로 출력하기 위한 설정입니다.
설정하면 이벤트 조회, 트리거 발동, 트리거 삭제 등의 작업이 분석 및 감사를 위해 기록됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 생성한 네임스페이스 |
#### 구현 예제
**Go**
```go
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,
TransactionSetting: 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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting(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")
}
```
**Java**
```java
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)
.withTransactionSetting(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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2Schedule.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(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;
```
**TypeScript**
```typescript
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)
.withTransactionSetting(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);
}
```
**Python**
```python
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_transaction_setting(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)
```
**GS2-Script**
```lua
client = gs2('schedule')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
transactionSetting=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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('schedule')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
transactionSetting=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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getNamespaceStatus
네임스페이스의 상태 조회
지정된 네임스페이스의 현재 상태를 조회합니다.
상태에는 네임스페이스가 활성 상태인지, 삭제되었는지가 포함됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| status | string | 네임스페이스의 상태
ACTIVE: 유효 / DELETED: 삭제됨 / |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->getNamespaceStatus(
(new GetNamespaceStatusRequest())
->withNamespaceName("namespace-0001")
);
$status = $result->getStatus();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
status = result.status;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
status = result.status;
```
---
### getNamespace
네임스페이스 조회
지정된 네임스페이스의 상세 정보를 조회합니다.
여기에는 네임스페이스의 이름, 설명 및 기타 설정 정보가 포함됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 네임스페이스 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->getNamespace(
(new GetNamespaceRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateNamespace
네임스페이스 갱신
지정된 네임스페이스의 설정을 갱신합니다.
네임스페이스의 설명이나 특정 설정을 변경할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | 트랜잭션 설정
스케줄 작업 실행 시 트랜잭션 처리 방식을 제어하는 설정입니다. |
| logSetting | [LogSetting](#logsetting) | | | | | 로그 출력 설정
스케줄 관련 작업 로그를 GS2-Log로 출력하기 위한 설정입니다.
설정하면 이벤트 조회, 트리거 발동, 트리거 삭제 등의 작업이 분석 및 감사를 위해 기록됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 갱신한 네임스페이스 |
#### 구현 예제
**Go**
```go
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"),
TransactionSetting: 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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting(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")
}
```
**Java**
```java
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")
.withTransactionSetting(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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2Schedule.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(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;
```
**TypeScript**
```typescript
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")
.withTransactionSetting(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);
}
```
**Python**
```python
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_transaction_setting(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)
```
**GS2-Script**
```lua
client = gs2('schedule')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
transactionSetting=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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('schedule')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
transactionSetting=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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteNamespace
네임스페이스 삭제
지정된 네임스페이스를 삭제합니다.
이 작업은 되돌릴 수 없으며, 삭제된 네임스페이스와 관련된 모든 데이터는 복구할 수 없게 됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 삭제한 네임스페이스 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->deleteNamespace(
(new DeleteNamespaceRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getServiceVersion
마이크로서비스 버전 조회
#### Request
요청 파라미터: 없음
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | string | 버전 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->getServiceVersion(
(new GetServiceVersionRequest())
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
client = gs2('schedule')
api_result = client.get_service_version({
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### dumpUserDataByUserId
지정한 사용자 ID에 연결된 데이터의 덤프 취득
개인정보 보호에 관한 법적 요건을 충족시키기 위해 사용하거나, 데이터의 백업 및 이관에 사용할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
반환값: 없음
#### 구현 예제
**Go**
```go
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")
}
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->dumpUserDataByUserId(
(new DumpUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
```
---
### checkDumpUserDataByUserId
지정한 사용자 ID에 연결된 데이터의 덤프가 완료되었는지 확인
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| url | string | 출력 데이터의 URL |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->checkDumpUserDataByUserId(
(new CheckDumpUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$url = $result->getUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
url = result.url;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
url = result.url;
```
---
### cleanUserDataByUserId
사용자 데이터 완전 삭제
지정된 사용자 ID에 연결된 데이터의 클리닝을 실행합니다.
이를 통해 특정 사용자 데이터를 프로젝트에서 안전하게 삭제할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
반환값: 없음
#### 구현 예제
**Go**
```go
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")
}
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->cleanUserDataByUserId(
(new CleanUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
```
---
### checkCleanUserDataByUserId
지정한 사용자 ID에 연결된 데이터의 삭제가 완료되었는지 확인
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
반환값: 없음
#### 구현 예제
**Go**
```go
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")
}
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->checkCleanUserDataByUserId(
(new CheckCleanUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
```
---
### prepareImportUserDataByUserId
지정한 사용자 ID에 연결된 데이터의 임포트 준비
임포트에 사용할 수 있는 데이터는 GS2 를 통해 익스포트하여 취득한 데이터로 한정되며, 오래된 데이터는 임포트에 실패할 수 있습니다.
익스포트한 사용자 ID와 다른 사용자 ID로 임포트할 수 있지만, 사용자 데이터의 페이로드 내에 사용자 ID가 포함되어 있는 경우에는 그렇지 않을 수 있습니다.
이 API의 반환값으로 응답된 URL에 익스포트한 zip 파일을 업로드하고 importUserDataByUserId 를 호출함으로써 실제 임포트 처리를 시작할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| uploadToken | string | 업로드 후 결과를 반영할 때 사용하는 토큰 |
| uploadUrl | string | 사용자 데이터 업로드 처리 실행에 사용하는 URL |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->prepareImportUserDataByUserId(
(new PrepareImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$uploadToken = $result->getUploadToken();
$uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
---
### importUserDataByUserId
지정한 사용자 ID에 연결된 데이터의 임포트 실행
임포트에 사용할 수 있는 데이터는 GS2 를 통해 익스포트하여 취득한 데이터로 한정되며, 오래된 데이터는 임포트에 실패할 수 있습니다.
익스포트한 사용자 ID와 다른 사용자 ID로 임포트할 수 있지만, 사용자 데이터의 페이로드 내에 사용자 ID가 포함되어 있는 경우에는 그렇지 않을 수 있습니다.
이 API를 호출하기 전에 prepareImportUserDataByUserId 를 호출하여 업로드 준비를 완료해야 합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| uploadToken | string | | ✓| | ~ 1024자 | 업로드 준비 시 수신한 토큰 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
반환값: 없음
#### 구현 예제
**Go**
```go
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")
}
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->importUserDataByUserId(
(new ImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withUploadToken("upload-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
```
---
### checkImportUserDataByUserId
지정한 사용자 ID에 연결된 데이터의 임포트가 완료되었는지 확인
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| uploadToken | string | | ✓| | ~ 1024자 | 업로드 준비 시 수신한 토큰 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| url | string | 출력 로그의 URL |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->checkImportUserDataByUserId(
(new CheckImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withUploadToken("upload-0001")
->withTimeOffsetToken(null)
);
$url = $result->getUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
url = result.url;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
url = result.url;
```
---
### describeTriggers
트리거 목록 취득
요청한 사용자에 대해 당겨진 트리거의 페이지네이션 리스트를 취득합니다. 트리거는 상대 스케줄 이벤트를 활성화하기 위해 사용되며, 유효기간(TTL)을 가집니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Trigger>](#trigger) | 트리거 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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")
}
```
**Java**
```java
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 items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeTriggersByUserId
사용자 ID를 지정하여 트리거 목록 취득
지정한 사용자에 대해 당겨진 트리거의 페이지네이션 리스트를 취득합니다. 트리거는 상대 스케줄 이벤트를 활성화하기 위해 사용되며, 유효기간(TTL)을 가집니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Trigger>](#trigger) | 트리거 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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")
}
```
**Java**
```java
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 items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### getTrigger
트리거 취득
이름, 작성 시각, 유효기간(TTL)을 포함한 지정된 트리거를 취득합니다. 요청한 사용자의 트리거 현재 상태를 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| triggerName | string | | ✓| | ~ 128자 | 트리거 이름
트리거 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Trigger](#trigger) | 트리거 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->getTrigger(
(new GetTriggerRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withTriggerName("trigger1")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getTriggerByUserId
사용자 ID를 지정하여 트리거 취득
지정한 사용자의 이름, 작성 시각, 유효기간(TTL)을 포함한 지정된 트리거를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| triggerName | string | | ✓| | ~ 128자 | 트리거 이름
트리거 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Trigger](#trigger) | 트리거 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### triggerByUserId
사용자 ID를 지정하여 트리거 실행
지정한 사용자의 트리거를 당깁니다. 트리거 전략에 따라 동작이 결정됩니다: 'renew'는 새로운 TTL로 리셋, 'extend'는 기존 TTL을 연장, 'drop'은 이미 당겨진 경우 무시, 'repeatCycleEnd'/'repeatCycleNextStart'/'absoluteEnd'는 지정한 이벤트의 스케줄에 유효기간을 맞춥니다. 트리거를 당기면 관련된 상대 스케줄 이벤트가 활성화됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| triggerName | string | | ✓| | ~ 128자 | 트리거 이름
트리거 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| triggerStrategy | 문자열 열거형
enum {
"renew",
"extend",
"drop",
"repeatCycleEnd",
"repeatCycleNextStart",
"absoluteEnd"
}
| | ✓| | | 트리거 실행 정책renew: 이미 트리거가 당겨진 경우 새로운 기간으로 다시 당기기 / extend: 이미 트리거가 당겨진 경우 기간 연장 / drop: 이미 트리거가 당겨진 경우 무시 / repeatCycleEnd: 지정한 이벤트의 반복 기간 종료 일시에 유효 기간이 만료되도록 트리거 당기기 / repeatCycleNextStart: 지정한 이벤트의 반복에서 다음 반복 시작 일시에 유효 기간이 만료되도록 트리거 당기기 / absoluteEnd: 지정한 이벤트의 종료 일시에 유효 기간이 만료되도록 트리거 당기기 / |
| ttl | int | {triggerStrategy} in ["renew", "extend", "drop"] | ✓※| | 0 ~ 2147483646 | 트리거 유효기간(초)
※ triggerStrategy이(가) "renew","extend","drop"이면 필수 |
| eventId | string | {triggerStrategy} in ["repeatCycleEnd", "repeatCycleNextStart", "absoluteEnd"] | ✓※| | ~ 1024자 | 이벤트 GRN
※ triggerStrategy이(가) "repeatCycleEnd","repeatCycleNextStart","absoluteEnd"이면 필수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Trigger](#trigger) | 당긴 트리거 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### extendTriggerByUserId
사용자 ID를 지정하여 트리거 기간 연장
지정한 사용자의 기존 트리거 유효기간을 지정한 초만큼 연장합니다. 트리거가 존재하지 않는 경우, 지정한 연장 기간을 TTL로 하는 새로운 트리거가 생성됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| triggerName | string | | ✓| | ~ 128자 | 트리거 이름
트리거 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| extendSeconds | int | | ✓| | 0 ~ 2147483646 | 트리거를 연장하는 기간(초) |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Trigger](#trigger) | 당긴 트리거 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteTrigger
트리거 삭제
요청한 사용자의 지정된 트리거를 삭제합니다. 트리거를 삭제하면 관련된 상대 스케줄 이벤트가 비활성화됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| triggerName | string | | ✓| | ~ 128자 | 트리거 이름
트리거 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Trigger](#trigger) | 삭제한 트리거 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->deleteTrigger(
(new DeleteTriggerRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withTriggerName("trigger1")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteTriggerByUserId
사용자 ID를 지정하여 트리거 삭제
지정한 사용자의 지정된 트리거를 삭제합니다. 트리거를 삭제하면 관련된 상대 스케줄 이벤트가 비활성화됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| triggerName | string | | ✓| | ~ 128자 | 트리거 이름
트리거 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Trigger](#trigger) | 삭제한 트리거 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### verifyTrigger
트리거가 당겨진 후 경과 시간 검증
트리거의 상태에 관한 조건을 검증합니다. verifyType은 다음을 설정할 수 있습니다: 'notTriggerd'는 트리거가 당겨지지 않았음을 검증, 'elapsed'는 트리거가 당겨진 후 지정한 분수가 경과했음을 검증, 'notElapsed'는 지정한 분수가 아직 경과하지 않았음을 검증합니다. 검증 조건이 충족되지 않으면 오류를 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| triggerName | string | | ✓| | ~ 128자 | 트리거 이름
트리거 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| verifyType | 문자열 열거형
enum {
"notTriggerd",
"elapsed",
"notElapsed"
}
| | ✓| | | 검증 종류notTriggerd: 트리거가 당겨지지 않음 / elapsed: 지정한 시간이 경과함 / notElapsed: 지정한 시간이 경과하지 않음 / |
| elapsedMinutes | int | {verifyType} in ["elapsed", "notElapsed"] | ✓※| | 0 ~ 2147483646 | 경과 시간(분)
※ verifyType이(가) "elapsed","notElapsed"이면 필수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Trigger](#trigger) | 트리거 |
#### 구현 예제
**Go**
```go
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")
}
item := result.Item
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->verifyTrigger(
(new VerifyTriggerRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withTriggerName("trigger-0001")
->withVerifyType("elapsed")
->withElapsedMinutes(60)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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)
);
Trigger item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
var item = result.Item;
```
**TypeScript**
```typescript
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)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
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)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### verifyTriggerByUserId
사용자 ID를 지정하여 트리거가 당겨진 후 경과 시간 검증
지정한 사용자의 트리거 상태에 관한 조건을 검증합니다. verifyType은 'notTriggerd', 'elapsed', 'notElapsed'를 설정할 수 있습니다. 검증 조건이 충족되지 않으면 오류를 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| triggerName | string | | ✓| | ~ 128자 | 트리거 이름
트리거 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| verifyType | 문자열 열거형
enum {
"notTriggerd",
"elapsed",
"notElapsed"
}
| | ✓| | | 검증 종류notTriggerd: 트리거가 당겨지지 않음 / elapsed: 지정한 시간이 경과함 / notElapsed: 지정한 시간이 경과하지 않음 / |
| elapsedMinutes | int | {verifyType} in ["elapsed", "notElapsed"] | ✓※| | 0 ~ 2147483646 | 경과 시간(분)
※ verifyType이(가) "elapsed","notElapsed"이면 필수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Trigger](#trigger) | 트리거 |
#### 구현 예제
**Go**
```go
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")
}
item := result.Item
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->verifyTriggerByUserId(
(new VerifyTriggerByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withTriggerName("trigger-0001")
->withVerifyType("elapsed")
->withElapsedMinutes(60)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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)
);
Trigger item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
var item = result.Item;
```
**TypeScript**
```typescript
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)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
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)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeEvents
이벤트 목록 조회
요청한 사용자의 현재 활성 상태인 이벤트 목록을 조회합니다. 스케줄이 현재 진행 중인 이벤트만 반환됩니다. 상대 스케줄 이벤트의 경우, 결과는 사용자의 트리거 상태에 따라 달라집니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Event>](#event) | 이벤트 목록 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->describeEvents(
(new DescribeEventsRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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 items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describeEventsByUserId
사용자 ID를 지정하여 이벤트 목록 조회
지정한 사용자의 현재 활성 상태인 이벤트 목록을 조회합니다. 스케줄이 현재 진행 중인 이벤트만 반환됩니다. 상대 스케줄 이벤트의 경우, 결과는 지정한 사용자의 트리거 상태에 따라 달라집니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Event>](#event) | 이벤트 목록 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->describeEventsByUserId(
(new DescribeEventsByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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 items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describeRawEvents
이벤트 목록 조회
사용자 컨텍스트나 스케줄 상태로 필터링하지 않고, 네임스페이스 내 모든 이벤트 정의의 목록을 조회합니다. 이벤트가 현재 활성 상태인지 여부와 관계없이 원본 이벤트 데이터를 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Event>](#event) | 이벤트 목록 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->describeRawEvents(
(new DescribeRawEventsRequest())
->withNamespaceName("namespace-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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 items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### getEvent
이벤트 조회
지정된 이벤트를 스케줄 상태와 함께 조회합니다. 이벤트가 현재 개최 기간 중인지 여부, 스케줄 시작/종료 시각, 반복 스케줄 정보, 글로벌 스케줄 여부를 반환합니다. isInSchedule 이 true 로 설정되어 있고 이벤트가 현재 활성 상태가 아닌 경우, NotFound 오류가 반환됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| eventName | string | | ✓| | ~ 128자 | 이벤트 이름
이벤트 고유의 이름. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| isInSchedule | bool | | | true | | 현재 개최 중인 이벤트만 조회 대상으로 할지 여부 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Event](#event) | 이벤트 |
| inSchedule | bool? | 현재 이벤트 기간 중인지 여부 |
| scheduleStartAt | long | 이벤트 기간 시작 시각 |
| scheduleEndAt | long | 이벤트 기간 종료 시각
이벤트 종류가 absolute 인 경우 EventModel 의 absoluteEnd 가 저장됩니다.
이벤트 종류가 relative 인 경우 scheduleEndAt 에는 트리거의 유효 기간 또는 EventModel 의 absoluteEnd 중 더 빨리 종료되는 쪽이 저장됩니다. |
| repeatSchedule | [RepeatSchedule](#repeatschedule) | 반복 정보 |
| isGlobalSchedule | bool? | 이벤트가 글로벌 스케줄인지 여부 |
#### 구현 예제
**Go**
```go
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
isGlobalSchedule := result.IsGlobalSchedule
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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();
$isGlobalSchedule = $result->getIsGlobalSchedule();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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();
boolean isGlobalSchedule = result.getIsGlobalSchedule();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
var isGlobalSchedule = result.IsGlobalSchedule;
```
**TypeScript**
```typescript
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();
const isGlobalSchedule = result.getIsGlobalSchedule();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
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
is_global_schedule = result.is_global_schedule
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;
isGlobalSchedule = result.isGlobalSchedule;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;
isGlobalSchedule = result.isGlobalSchedule;
```
---
### getEventByUserId
사용자 ID를 지정하여 이벤트 조회
지정한 사용자에 대한 지정된 이벤트를 스케줄 상태와 함께 조회합니다. 이벤트가 현재 개최 기간 중인지 여부, 스케줄 시작/종료 시각, 반복 스케줄 정보, 글로벌 스케줄 여부를 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| eventName | string | | ✓| | ~ 128자 | 이벤트 이름
이벤트 고유의 이름. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| isInSchedule | bool | | | true | | 현재 개최 중인 이벤트만 조회 대상으로 할지 여부 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Event](#event) | 이벤트 |
| inSchedule | bool? | 현재 이벤트 기간 중인지 여부 |
| scheduleStartAt | long | 이벤트 기간 시작 시각 |
| scheduleEndAt | long | 이벤트 기간 종료 시각
이벤트 종류가 absolute 인 경우 EventModel 의 absoluteEnd 가 저장됩니다.
이벤트 종류가 relative 인 경우 scheduleEndAt 에는 트리거의 유효 기간 또는 EventModel 의 absoluteEnd 중 더 빨리 종료되는 쪽이 저장됩니다. |
| repeatSchedule | [RepeatSchedule](#repeatschedule) | 반복 정보 |
| isGlobalSchedule | bool? | 이벤트가 글로벌 스케줄인지 여부 |
#### 구현 예제
**Go**
```go
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
isGlobalSchedule := result.IsGlobalSchedule
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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();
$isGlobalSchedule = $result->getIsGlobalSchedule();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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();
boolean isGlobalSchedule = result.getIsGlobalSchedule();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
var isGlobalSchedule = result.IsGlobalSchedule;
```
**TypeScript**
```typescript
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();
const isGlobalSchedule = result.getIsGlobalSchedule();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
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
is_global_schedule = result.is_global_schedule
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;
isGlobalSchedule = result.isGlobalSchedule;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;
isGlobalSchedule = result.isGlobalSchedule;
```
---
### getRawEvent
이벤트 조회
사용자 컨텍스트 없이 원본 이벤트 정의를 조회합니다. 특정 사용자의 트리거 상태에 대한 스케줄 상태 평가 없이 이벤트 데이터를 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| eventName | string | | ✓| | ~ 128자 | 이벤트 이름
이벤트 고유의 이름. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Event](#event) | 이벤트 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->getRawEvent(
(new GetRawEventRequest())
->withNamespaceName("namespace-0001")
->withEventName("event-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### verifyEvent
이벤트 개최 기간인지 검증
지정된 이벤트가 현재 활성 스케줄 기간 내에 있는지 검증합니다. verifyType 을 'inSchedule' 로 설정하면 이벤트가 활성 상태임을 검증하고, 'notInSchedule' 로 설정하면 활성 상태가 아님을 검증합니다. 검증 조건이 충족되지 않으면 오류가 반환됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| eventName | string | | ✓| | ~ 128자 | 이벤트 이름
이벤트 고유의 이름. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| verifyType | 문자열 열거형
enum {
"inSchedule",
"notInSchedule"
}
| | ✓| | | 검증 종류inSchedule: 이벤트의 개최 기간임 / notInSchedule: 이벤트의 개최 기간이 아님 / |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Event](#event) | 이벤트 |
| inSchedule | bool? | 현재 이벤트 기간 중인지 여부 |
| scheduleStartAt | long | 이벤트 기간 시작 시각 |
| scheduleEndAt | long | 이벤트 기간 종료 시각
이벤트 종류가 absolute 인 경우 EventModel 의 absoluteEnd 가 저장됩니다.
이벤트 종류가 relative 인 경우 scheduleEndAt 에는 트리거의 유효 기간 또는 EventModel 의 absoluteEnd 중 더 빨리 종료되는 쪽이 저장됩니다. |
| repeatSchedule | [RepeatSchedule](#repeatschedule) | 반복 정보 |
| isGlobalSchedule | bool? | 이벤트가 글로벌 스케줄인지 여부 |
#### 구현 예제
**Go**
```go
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")
}
item := result.Item
inSchedule := result.InSchedule
scheduleStartAt := result.ScheduleStartAt
scheduleEndAt := result.ScheduleEndAt
repeatSchedule := result.RepeatSchedule
isGlobalSchedule := result.IsGlobalSchedule
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->verifyEvent(
(new VerifyEventRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withEventName("event-0001")
->withVerifyType("inSchedule")
);
$item = $result->getItem();
$inSchedule = $result->getInSchedule();
$scheduleStartAt = $result->getScheduleStartAt();
$scheduleEndAt = $result->getScheduleEndAt();
$repeatSchedule = $result->getRepeatSchedule();
$isGlobalSchedule = $result->getIsGlobalSchedule();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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")
);
Event item = result.getItem();
boolean inSchedule = result.getInSchedule();
long scheduleStartAt = result.getScheduleStartAt();
long scheduleEndAt = result.getScheduleEndAt();
RepeatSchedule repeatSchedule = result.getRepeatSchedule();
boolean isGlobalSchedule = result.getIsGlobalSchedule();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
var item = result.Item;
var inSchedule = result.InSchedule;
var scheduleStartAt = result.ScheduleStartAt;
var scheduleEndAt = result.ScheduleEndAt;
var repeatSchedule = result.RepeatSchedule;
var isGlobalSchedule = result.IsGlobalSchedule;
```
**TypeScript**
```typescript
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")
);
const item = result.getItem();
const inSchedule = result.getInSchedule();
const scheduleStartAt = result.getScheduleStartAt();
const scheduleEndAt = result.getScheduleEndAt();
const repeatSchedule = result.getRepeatSchedule();
const isGlobalSchedule = result.getIsGlobalSchedule();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
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')
)
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
is_global_schedule = result.is_global_schedule
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;
isGlobalSchedule = result.isGlobalSchedule;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;
isGlobalSchedule = result.isGlobalSchedule;
```
---
### verifyEventByUserId
사용자 ID를 지정하여 이벤트 개최 기간인지 검증
지정한 사용자에 대해 지정된 이벤트가 현재 활성 스케줄 기간 내에 있는지 검증합니다. verifyType 은 'inSchedule' 또는 'notInSchedule' 을 설정할 수 있습니다. 검증 조건이 충족되지 않으면 오류가 반환됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| eventName | string | | ✓| | ~ 128자 | 이벤트 이름
이벤트 고유의 이름. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| verifyType | 문자열 열거형
enum {
"inSchedule",
"notInSchedule"
}
| | ✓| | | 검증 종류inSchedule: 이벤트의 개최 기간임 / notInSchedule: 이벤트의 개최 기간이 아님 / |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Event](#event) | 이벤트 |
| inSchedule | bool? | 현재 이벤트 기간 중인지 여부 |
| scheduleStartAt | long | 이벤트 기간 시작 시각 |
| scheduleEndAt | long | 이벤트 기간 종료 시각
이벤트 종류가 absolute 인 경우 EventModel 의 absoluteEnd 가 저장됩니다.
이벤트 종류가 relative 인 경우 scheduleEndAt 에는 트리거의 유효 기간 또는 EventModel 의 absoluteEnd 중 더 빨리 종료되는 쪽이 저장됩니다. |
| repeatSchedule | [RepeatSchedule](#repeatschedule) | 반복 정보 |
| isGlobalSchedule | bool? | 이벤트가 글로벌 스케줄인지 여부 |
#### 구현 예제
**Go**
```go
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")
}
item := result.Item
inSchedule := result.InSchedule
scheduleStartAt := result.ScheduleStartAt
scheduleEndAt := result.ScheduleEndAt
repeatSchedule := result.RepeatSchedule
isGlobalSchedule := result.IsGlobalSchedule
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->verifyEventByUserId(
(new VerifyEventByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withEventName("event-0001")
->withVerifyType("inSchedule")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$inSchedule = $result->getInSchedule();
$scheduleStartAt = $result->getScheduleStartAt();
$scheduleEndAt = $result->getScheduleEndAt();
$repeatSchedule = $result->getRepeatSchedule();
$isGlobalSchedule = $result->getIsGlobalSchedule();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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)
);
Event item = result.getItem();
boolean inSchedule = result.getInSchedule();
long scheduleStartAt = result.getScheduleStartAt();
long scheduleEndAt = result.getScheduleEndAt();
RepeatSchedule repeatSchedule = result.getRepeatSchedule();
boolean isGlobalSchedule = result.getIsGlobalSchedule();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
var item = result.Item;
var inSchedule = result.InSchedule;
var scheduleStartAt = result.ScheduleStartAt;
var scheduleEndAt = result.ScheduleEndAt;
var repeatSchedule = result.RepeatSchedule;
var isGlobalSchedule = result.IsGlobalSchedule;
```
**TypeScript**
```typescript
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)
);
const item = result.getItem();
const inSchedule = result.getInSchedule();
const scheduleStartAt = result.getScheduleStartAt();
const scheduleEndAt = result.getScheduleEndAt();
const repeatSchedule = result.getRepeatSchedule();
const isGlobalSchedule = result.getIsGlobalSchedule();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
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)
)
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
is_global_schedule = result.is_global_schedule
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;
isGlobalSchedule = result.isGlobalSchedule;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
inSchedule = result.inSchedule;
scheduleStartAt = result.scheduleStartAt;
scheduleEndAt = result.scheduleEndAt;
repeatSchedule = result.repeatSchedule;
isGlobalSchedule = result.isGlobalSchedule;
```
---
### exportMaster
모델 마스터를 활성화 가능한 마스터 데이터 형식으로 익스포트
현재 등록되어 있는 이벤트 마스터를 활성화 가능한 마스터 데이터 형식으로 익스포트합니다. 익스포트된 데이터에는 절대/상대 타이밍, 반복 설정, 트리거 설정을 포함한 모든 이벤트 스케줄 정의가 포함됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentEventMaster](#currenteventmaster) | 활성화 가능한 마스터 데이터 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->exportMaster(
(new ExportMasterRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getCurrentEventMaster
현재 활성화된 이벤트의 마스터 데이터를 취득
스케줄 평가에 사용되고 있는 모든 이벤트 스케줄 정의를 포함한, 현재 활성화된 이벤트 마스터 데이터를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentEventMaster](#currenteventmaster) | 현재 활성화된 이벤트의 마스터 데이터 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->getCurrentEventMaster(
(new GetCurrentEventMasterRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### preUpdateCurrentEventMaster
현재 활성화된 이벤트의 마스터 데이터를 업데이트(3단계 버전)
1MB를 초과하는 마스터 데이터를 업로드하는 경우, 3단계로 업데이트를 수행합니다.
1. 이 API를 실행하여 업로드용 토큰과 URL을 취득합니다.
2. 취득한 URL에 마스터 데이터를 업로드합니다.
3. UpdateCurrentModelMaster에 업로드로 취득한 토큰을 전달하여 실행하고, 마스터 데이터를 반영합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| uploadToken | string | 업로드 후 결과를 반영할 때 사용하는 토큰 |
| uploadUrl | string | 업로드 처리 실행에 사용하는 URL |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->preUpdateCurrentEventMaster(
(new PreUpdateCurrentEventMasterRequest())
->withNamespaceName("namespace-0001")
);
$uploadToken = $result->getUploadToken();
$uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
---
### updateCurrentEventMaster
현재 활성화된 이벤트의 마스터 데이터를 업데이트
현재 활성화된 이벤트 마스터 데이터를 업데이트합니다. 대용량 마스터 데이터에 대응하기 위해 직접 업데이트 모드와 사전 업로드 모드를 모두 지원합니다. 사전 업로드 모드에서는 PreUpdate API로 취득한 업로드 토큰을 사용하여 설정을 읽어들입니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| mode | 문자열 열거형
enum {
"direct",
"preUpload"
}
| | | "direct" | | 업데이트 모드direct: 마스터 데이터를 직접 업데이트 / preUpload: 마스터 데이터를 업로드한 후 업데이트 / |
| settings | string | {mode} == "direct" | ✓※| | ~ 5242880 바이트 (5MB) | 마스터 데이터
※ mode이(가) "direct" 이면 필수 |
| uploadToken | string | {mode} == "preUpload" | ✓※| | ~ 1024자 | 사전 업로드로 획득한 토큰
업로드한 마스터 데이터를 적용하기 위해 사용됩니다.
※ mode이(가) "preUpload" 이면 필수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentEventMaster](#currenteventmaster) | 업데이트된 현재 활성화된 이벤트의 마스터 데이터 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateCurrentEventMasterFromGitHub
현재 활성화된 이벤트의 마스터 데이터를 GitHub에서 업데이트
지정된 체크아웃 설정을 사용하여 GitHub 리포지토리에서 마스터 데이터를 체크아웃하고, 현재 활성화된 이벤트 마스터 데이터를 업데이트합니다. GitHub와의 인증에는 키 서비스를 통해 API 키가 복호화됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| checkoutSetting | [GitHubCheckoutSetting](#githubcheckoutsetting) | | ✓| | | GitHub에서 마스터 데이터를 체크아웃하는 설정 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentEventMaster](#currenteventmaster) | 업데이트된 현재 활성화된 이벤트의 마스터 데이터 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeEventMasters
이벤트 마스터 목록 조회
이벤트 마스터의 페이지네이션 목록을 조회합니다. 이벤트 이름의 접두사로 필터링할 수 있습니다. 이벤트 마스터는 절대/상대 타이밍, 반복 설정, 트리거 연결 등의 이벤트 스케줄을 정의합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| namePrefix | string | | | | ~ 64자 | 이벤트 이름 필터 접두사 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<EventMaster>](#eventmaster) | 이벤트 마스터 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
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"),
NamePrefix: nil,
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->describeEventMasters(
(new DescribeEventMastersRequest())
->withNamespaceName("namespace-0001")
->withNamePrefix(null)
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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")
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeEventMasters(
new Gs2.Gs2Schedule.Request.DescribeEventMastersRequest()
.WithNamespaceName("namespace-0001")
.WithNamePrefix(null)
.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;
```
**TypeScript**
```typescript
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")
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
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_name_prefix(None)
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('schedule')
api_result = client.describe_event_masters({
namespaceName="namespace-0001",
namePrefix=nil,
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('schedule')
api_result_handler = client.describe_event_masters_async({
namespaceName="namespace-0001",
namePrefix=nil,
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createEventMaster
이벤트 마스터 신규 생성
스케줄 타입(절대 또는 상대), 시작/종료 시각, 반복 설정(일간, 주간, 월간), 상대 스케줄 이벤트용 선택적 트리거 이름을 가진 새로운 이벤트 마스터를 생성합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| name | string | | ✓| | ~ 128자 | 이벤트 이름
이벤트 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| scheduleType | 문자열 열거형
enum {
"absolute",
"relative"
}
| | ✓| | | 스케줄 타입
이벤트 기간을 정의하는 방식을 결정합니다.
"absolute"는 모든 플레이어에게 동일하게 적용되는 고정된 시작/종료 타임스탬프를 사용합니다.
"relative"는 플레이어별 트리거를 기점으로 사용하여, 개인화된 이벤트 기간을 구현합니다(예: 각 플레이어가 처음 로그인한 시점부터 24시간).absolute: 고정 기간 / relative: 플레이어별 기간 / |
| absoluteBegin | long | | | | | 절대 시작 일시
절대 스케줄링에서 이벤트 기간의 고정 시작 시각입니다.
모든 플레이어가 동일한 시작 시각을 공유합니다. 절대 이벤트에서 설정하지 않으면 이벤트는 과거부터 시작된 것으로 취급됩니다.
UNIX 시간(밀리초)으로 표현됩니다. |
| absoluteEnd | long | | | | | 절대 종료 일시
절대 스케줄링에서 이벤트 기간의 고정 종료 시각입니다.
모든 플레이어가 동일한 종료 시각을 공유합니다. 절대 이벤트에서 설정하지 않으면 이벤트는 종료되지 않는 것으로 취급됩니다.
UNIX 시간(밀리초)으로 표현됩니다. |
| relativeTriggerName | string | {scheduleType} == "relative" | ✓※| | ~ 128자 | 이벤트 시작 트리거 이름
게임 플레이어별로 이벤트 기간을 설정하는(`relative`) 경우, 이벤트 시작의 기점이 되는 트리거의 이름을 지정합니다.
영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다.
※ scheduleType이(가) "relative" 이면 필수 |
| repeatSetting | [RepeatSetting](#repeatsetting) | | ✓| | | 반복 설정
이벤트 기간 내에서 반복되는 유효 시간대에 대한 설정입니다.
활성 기간을 특정 시간대, 요일, 월중 날짜, 또는 사용자 지정 활성/비활성 일 주기로 좁힐 수 있습니다.
반복 패턴 없이 이벤트 기간 전체를 활성 상태로 유지하려면 repeatType을 "always"로 설정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [EventMaster](#eventmaster) | 생성한 이벤트 마스터 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getEventMaster
이벤트 마스터 조회
스케줄 타입, 시작/종료 시각, 반복 설정, 트리거 설정을 포함하여 지정된 이벤트 마스터를 조회합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| eventName | string | | ✓| | ~ 128자 | 이벤트 이름
이벤트 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [EventMaster](#eventmaster) | 이벤트 마스터 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->getEventMaster(
(new GetEventMasterRequest())
->withNamespaceName("namespace-0001")
->withEventName("event-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateEventMaster
이벤트 마스터 갱신
지정된 이벤트 마스터의 스케줄 타입, 시작/종료 시각, 반복 설정, 트리거 설정 등의 속성을 갱신합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| eventName | string | | ✓| | ~ 128자 | 이벤트 이름
이벤트 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| scheduleType | 문자열 열거형
enum {
"absolute",
"relative"
}
| | ✓| | | 스케줄 타입
이벤트 기간을 정의하는 방식을 결정합니다.
"absolute"는 모든 플레이어에게 동일하게 적용되는 고정된 시작/종료 타임스탬프를 사용합니다.
"relative"는 플레이어별 트리거를 기점으로 사용하여, 개인화된 이벤트 기간을 구현합니다(예: 각 플레이어가 처음 로그인한 시점부터 24시간).absolute: 고정 기간 / relative: 플레이어별 기간 / |
| absoluteBegin | long | | | | | 절대 시작 일시
절대 스케줄링에서 이벤트 기간의 고정 시작 시각입니다.
모든 플레이어가 동일한 시작 시각을 공유합니다. 절대 이벤트에서 설정하지 않으면 이벤트는 과거부터 시작된 것으로 취급됩니다.
UNIX 시간(밀리초)으로 표현됩니다. |
| absoluteEnd | long | | | | | 절대 종료 일시
절대 스케줄링에서 이벤트 기간의 고정 종료 시각입니다.
모든 플레이어가 동일한 종료 시각을 공유합니다. 절대 이벤트에서 설정하지 않으면 이벤트는 종료되지 않는 것으로 취급됩니다.
UNIX 시간(밀리초)으로 표현됩니다. |
| relativeTriggerName | string | {scheduleType} == "relative" | ✓※| | ~ 128자 | 이벤트 시작 트리거 이름
게임 플레이어별로 이벤트 기간을 설정하는(`relative`) 경우, 이벤트 시작의 기점이 되는 트리거의 이름을 지정합니다.
영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다.
※ scheduleType이(가) "relative" 이면 필수 |
| repeatSetting | [RepeatSetting](#repeatsetting) | | ✓| | | 반복 설정
이벤트 기간 내에서 반복되는 유효 시간대에 대한 설정입니다.
활성 기간을 특정 시간대, 요일, 월중 날짜, 또는 사용자 지정 활성/비활성 일 주기로 좁힐 수 있습니다.
반복 패턴 없이 이벤트 기간 전체를 활성 상태로 유지하려면 repeatType을 "always"로 설정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [EventMaster](#eventmaster) | 갱신한 이벤트 마스터 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$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")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteEventMaster
이벤트 마스터 삭제
지정된 이벤트 마스터를 삭제합니다. 이는 마스터 정의만 삭제하는 것으로, 현재 활성화되어 있는 이벤트 마스터 데이터는 다음 마스터 데이터 갱신 시까지 영향을 받지 않습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| eventName | string | | ✓| | ~ 128자 | 이벤트 이름
이벤트 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [EventMaster](#eventmaster) | 삭제한 이벤트 마스터 |
#### 구현 예제
**Go**
```go
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
```
**PHP**
```php
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 Gs2ScheduleRestClient(
$session
);
try {
$result = $client->deleteEventMaster(
(new DeleteEventMasterRequest())
->withNamespaceName("namespace-0001")
->withEventName("event-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ScheduleRestClient(session);
AsyncResult 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;
```
**TypeScript**
```typescript
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);
}
```
**Python**
```python
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)
```
**GS2-Script**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---