> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-MegaField SDK API 레퍼런스
각종 프로그래밍 언어용 GS2-MegaField SDK의 모델 사양과 API 레퍼런스
## 모델
### Namespace
네임스페이스
네임스페이스는 하나의 프로젝트 내에서 동일한 서비스를 서로 다른 용도로 여러 개 이용하기 위한 엔티티입니다.
GS2의 각 서비스는 네임스페이스 단위로 관리됩니다. 네임스페이스가 다르면 동일한 서비스라도 완전히 독립된 데이터 공간으로 취급됩니다.
따라서 각 서비스의 이용을 시작하려면 먼저 네임스페이스를 생성해야 합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024자 | 네임스페이스 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명 |
| logSetting | [LogSetting](#logsetting) | | | | | 로그 출력 설정 |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeNamespaces - 네임스페이스 목록 조회
createNamespace - 네임스페이스 신규 생성
getNamespace - 네임스페이스 조회
updateNamespace - 네임스페이스 갱신
deleteNamespace - 네임스페이스 삭제
---
### LogSetting
로그 출력 설정
로그 데이터의 출력 설정을 관리합니다. 이 타입은 로그 데이터를 기록하는 데 사용되는 로그 네임스페이스의 식별자(Namespace ID)를 보유합니다.
로그 네임스페이스 ID는 로그 데이터를 집계하여 저장할 대상 GS2-Log의 네임스페이스를 지정합니다.
이 설정을 통해 이 네임스페이스 이하의 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" 이면 필수 |
**관련 메서드:**
updateCurrentFieldMasterFromGitHub - 현재 활성화된 필드 모델의 마스터 데이터를 GitHub에서 업데이트
---
### Layer
레이어
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| layerId | string | | ※ | | ~ 1024자 | 레이어 GRN
※ 서버가 자동으로 설정 |
| areaModelName | string | | ✓ | | ~ 128자 | 에어리어 이름 |
| layerModelName | string | | ✓ | | ~ 128자 | 레이어 이름 |
| numberOfMinEntries | int | | | 5 | 1 ~ 1000 | 노드 내 엔티티 수가 지정값을 밑돌면 다른 노드와의 결합을 시도합니다 |
| numberOfMaxEntries | int | | | 20 | 1 ~ 1000 | 노드 내 엔티티 수가 지정값을 웃돌면 노드 분할을 시도합니다 |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
---
### Spatial
공간 정보
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| spatialId | string | | ※ | | ~ 1024자 | 공간 정보 GRN
※ 서버가 자동으로 설정 |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| areaModelName | string | | ✓ | | ~ 128자 | 에어리어 이름 |
| layerModelName | string | | ✓ | | ~ 128자 | 레이어 이름 |
| position | [Position](#position) | | ✓ | | | 좌표 |
| vector | [Vector](#vector) | | ✓ | | | 방향 |
| r | float | | | 1 | 0 ~ 10000 | 반경 |
| lastSyncAt | long | | | | | 레이어에 대한 마지막 동기화 일시 |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
**관련 메서드:**
putPosition - 좌표 설정
putPositionByUserId - 사용자 ID를 지정하여 좌표 설정
fetchPosition - 좌표 조회
fetchPositionFromSystem - 좌표 조회
action - 좌표 설정
actionByUserId - 사용자 ID를 지정하여 좌표 설정
---
### AreaModel
에어리어는 공간을 분할하는 것으로, 같은 좌표라도 에어리어가 다르면 별도의 공간으로 취급할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| areaModelId | string | | ※ | | ~ 1024자 | 에어리어 모델 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 에어리어 모델 이름 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| layerModels | [List<LayerModel>](#layermodel) | | | [] | 0 ~ 1000 items | 레이어 모델 목록 |
**관련 메서드:**
describeAreaModels - 에어리어 모델 목록 조회
getAreaModel - 에어리어 모델 조회
---
### LayerModel
레이어는 하나의 공간 내에서 여러 개의 논리적 계층을 구현합니다.
예를 들어, 캐릭터가 대량으로 존재하는 공간에서 에너미가 보이지 않게 되는 문제를 해결합니다.
레이어 1에는 캐릭터를 배치합니다. 레이어 2에 에너미를 배치한 경우, 레이어마다 지정한 거리 내에서의 취득 수량을 지정할 수 있으므로 보이지 않게 될 걱정이 없습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| layerModelId | string | | ※ | | ~ 1024자 | 레이어 모델 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 레이어 모델 이름 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
**관련 메서드:**
describeLayerModels - 레이어 모델 목록 조회
getLayerModel - 레이어 모델 조회
**관련 모델:**
AreaModel - 에어리어는 공간을 분할하는 것으로, 같은 좌표라도 에어리어가 다르면 별도의 공간으로 취급할 수 있습니다.
---
### Position
좌표
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| x | float | | ✓ | | -1048574 ~ 1048574 | X 좌표 |
| y | float | | ✓ | | -1048574 ~ 1048574 | Y 좌표 |
| z | float | | ✓ | | -1048574 ~ 1048574 | Z 좌표 |
**관련 메서드:**
putPosition - 좌표 설정
putPositionByUserId - 사용자 ID를 지정하여 좌표 설정
nearUserIds - 근처에 있는 사용자 ID 리스트 조회
nearUserIdsFromSystem - 근처에 있는 사용자 ID 리스트 조회
**관련 모델:**
Spatial - 공간 정보
MyPosition - 내 위치 정보
---
### MyPosition
내 위치 정보
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| position | [Position](#position) | | ✓ | | | 좌표 |
| vector | [Vector](#vector) | | ✓ | | | 방향 |
| r | float | | | 1 | 0 ~ 10000 | 반경 |
**관련 메서드:**
action - 좌표 설정
actionByUserId - 사용자 ID를 지정하여 좌표 설정
---
### Scope
취득할 주변 상황
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| layerName | string | | ✓ | | ~ 128자 | 레이어 모델 이름 |
| r | float | | ✓ | | 1 ~ 16777214 | 반경 |
| limit | int | | ✓ | | 1 ~ 100 | 최대 개수 |
---
### Vector
좌표
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| x | float | | ✓ | | -1048574 ~ 1048574 | X 좌표 |
| y | float | | ✓ | | -1048574 ~ 1048574 | Y 좌표 |
| z | float | | ✓ | | -1048574 ~ 1048574 | Z 좌표 |
**관련 메서드:**
putPosition - 좌표 설정
putPositionByUserId - 사용자 ID를 지정하여 좌표 설정
**관련 모델:**
Spatial - 공간 정보
MyPosition - 내 위치 정보
---
### CurrentFieldMaster
현재 활성화된 필드 모델의 마스터 데이터
현재 네임스페이스 내에서 유효한 필드 모델의 정의를 기술한 마스터 데이터입니다.
GS2에서는 마스터 데이터의 관리에 JSON 형식 파일을 사용합니다.
파일을 업로드함으로써 실제로 서버에 설정을 반영할 수 있습니다.
JSON 파일을 작성하는 방법으로, 매니지먼트 콘솔 내에 마스터 데이터 에디터를 제공하고 있습니다.
또한 게임 운영에 더 적합한 툴을 직접 제작하여 적절한 형식의 JSON 파일을 출력하는 방식으로도 서비스를 이용할 수 있습니다.
**ℹ️ Note**
JSON 파일 형식에 대해서는 [GS2-MegaField 마스터 데이터 레퍼런스](api_reference/mega_field/master_data/)를 참조해 주세요.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024자 | 네임스페이스 GRN
※ 서버가 자동으로 설정 |
| settings | string | | ✓ | | ~ 5242880 바이트 (5MB) | 마스터 데이터 |
**관련 메서드:**
exportMaster - 활성화 가능한 마스터 데이터 형식으로 모델 마스터 내보내기
getCurrentFieldMaster - 현재 활성화된 필드 모델의 마스터 데이터 조회
updateCurrentFieldMaster - 현재 활성화된 필드 모델의 마스터 데이터 업데이트
updateCurrentFieldMasterFromGitHub - 현재 활성화된 필드 모델의 마스터 데이터를 GitHub에서 업데이트
---
### AreaModelMaster
에어리어는 공간을 분할하는 것으로, 같은 좌표라도 에어리어가 다르면 별도의 공간으로 취급할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| areaModelMasterId | string | | ※ | | ~ 1024자 | 에어리어 모델 마스터 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 에어리어 모델 이름 |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeAreaModelMasters - 에어리어 모델 마스터 목록 조회
createAreaModelMaster - 에어리어 모델 마스터 신규 작성
getAreaModelMaster - 에어리어 모델 마스터 조회
updateAreaModelMaster - 에어리어 모델 마스터 업데이트
deleteAreaModelMaster - 에어리어 모델 마스터 삭제
---
### LayerModelMaster
레이어는 하나의 공간 내에서 여러 개의 논리적 계층을 구현합니다.
예를 들어, 캐릭터가 대량으로 존재하는 공간에서 에너미가 보이지 않게 되는 문제를 해결합니다.
레이어 1에는 캐릭터를 배치합니다. 레이어 2에 에너미를 배치한 경우, 레이어마다 지정한 거리 내에서의 취득 수량을 지정할 수 있으므로 보이지 않게 될 걱정이 없습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| layerModelMasterId | string | | ※ | | ~ 1024자 | 레이어 모델 마스터 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 레이어 모델 이름 |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeLayerModelMasters - 레이어 모델 마스터 목록 조회
createLayerModelMaster - 레이어 모델 마스터 신규 작성
getLayerModelMaster - 레이어 모델 마스터 조회
updateLayerModelMaster - 레이어 모델 마스터 업데이트
deleteLayerModelMaster - 레이어 모델 마스터 삭제
---
## 메서드
### 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/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&mega_field.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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DescribeNamespacesRequest;
import io.gs2.megaField.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2MegaField.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2MegaField.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 mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.describe_namespaces(
mega_field.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('mega_field')
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('mega_field')
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자 | 설명 |
| logSetting | [LogSetting](#logsetting) | | | | | 로그 출력 설정 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 생성한 네임스페이스 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&mega_field.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
LogSetting: &megaField.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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withLogSetting((new \Gs2\MegaField\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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.CreateNamespaceRequest;
import io.gs2.megaField.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withLogSetting(new io.gs2.megaField.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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2MegaField.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithLogSetting(new Gs2.Gs2MegaField.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.createNamespace(
new Gs2MegaField.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withLogSetting(new Gs2MegaField.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 mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.create_namespace(
mega_field.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_log_setting(
mega_field.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('mega_field')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('mega_field')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['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/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&mega_field.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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetNamespaceStatusRequest;
import io.gs2.megaField.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2MegaField.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2MegaField.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.get_namespace_status(
mega_field.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
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('mega_field')
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/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&mega_field.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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetNamespaceRequest;
import io.gs2.megaField.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2MegaField.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.getNamespace(
new Gs2MegaField.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.get_namespace(
mega_field.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
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('mega_field')
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자 | 설명 |
| logSetting | [LogSetting](#logsetting) | | | | | 로그 출력 설정 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 갱신한 네임스페이스 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&mega_field.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
LogSetting: &megaField.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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withLogSetting((new \Gs2\MegaField\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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.UpdateNamespaceRequest;
import io.gs2.megaField.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withLogSetting(new io.gs2.megaField.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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2MegaField.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithLogSetting(new Gs2.Gs2MegaField.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2MegaField.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withLogSetting(new Gs2MegaField.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 mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.update_namespace(
mega_field.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_log_setting(
mega_field.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('mega_field')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('mega_field')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['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/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&mega_field.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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DeleteNamespaceRequest;
import io.gs2.megaField.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2MegaField.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2MegaField.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.delete_namespace(
mega_field.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
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('mega_field')
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/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&mega_field.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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetServiceVersionRequest;
import io.gs2.megaField.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2MegaField.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2MegaField.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.get_service_version(
mega_field.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
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('mega_field')
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;
```
---
### putPosition
좌표 설정
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 이름 |
| position | [Position](#position) | | ✓| | | 좌표 |
| vector | [Vector](#vector) | | ✓| | | 방향 |
| r | float | | | 1 | 0 ~ 10000 | 반경 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Spatial](#spatial) | 물체 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.PutPosition(
&mega_field.PutPositionRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-0001"),
Position: &megaField.Position{
X: pointy.Float32(0),
Y: pointy.Float32(1),
Z: pointy.Float32(2),
},
Vector: &megaField.Vector{
X: pointy.Float32(10),
Y: pointy.Float32(11),
Z: pointy.Float32(12),
},
R: pointy.Float32(5),
}
)
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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\PutPositionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->putPosition(
(new PutPositionRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-0001")
->withPosition((new Position())
->withX(0)
->withY(1)
->withZ(2)
)
->withVector((new Vector())
->withX(10)
->withY(11)
->withZ(12)
)
->withR(5)
);
$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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.PutPositionRequest;
import io.gs2.megaField.result.PutPositionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
PutPositionResult result = client.putPosition(
new PutPositionRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPosition(new Position()
.withX(0f)
.withY(1f)
.withZ(2f)
)
.withVector(new Vector()
.withX(10f)
.withY(11f)
.withZ(12f)
)
.withR(5f)
);
Spatial 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.PutPosition(
new Gs2.Gs2MegaField.Request.PutPositionRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-0001")
.WithPosition(new Gs2.Gs2MegaField.Model.Position()
.WithX(0f)
.WithY(1f)
.WithZ(2f)
)
.WithVector(new Gs2.Gs2MegaField.Model.Vector()
.WithX(10f)
.WithY(11f)
.WithZ(12f)
)
.WithR(5f),
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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.putPosition(
new Gs2MegaField.PutPositionRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPosition(new Gs2MegaField.model.Position()
.withX(0)
.withY(1)
.withZ(2)
)
.withVector(new Gs2MegaField.model.Vector()
.withX(10)
.withY(11)
.withZ(12)
)
.withR(5)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.put_position(
mega_field.PutPositionRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
.with_position(mega_field.Position()
.with_x(0)
.with_y(1)
.with_z(2)
)
.with_vector(mega_field.Vector()
.with_x(10)
.with_y(11)
.with_z(12)
)
.with_r(5)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.put_position({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
position={
x=0,
y=1,
z=2,
},
vector={
x=10,
y=11,
z=12,
},
r=5,
})
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('mega_field')
api_result_handler = client.put_position_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
position={
x=0,
y=1,
z=2,
},
vector={
x=10,
y=11,
z=12,
},
r=5,
})
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;
```
---
### putPositionByUserId
사용자 ID를 지정하여 좌표 설정
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 이름 |
| position | [Position](#position) | | ✓| | | 좌표 |
| vector | [Vector](#vector) | | ✓| | | 방향 |
| r | float | | | 1 | 0 ~ 10000 | 반경 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Spatial](#spatial) | 물체 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.PutPositionByUserId(
&mega_field.PutPositionByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-0001"),
Position: &megaField.Position{
X: pointy.Float32(0),
Y: pointy.Float32(1),
Z: pointy.Float32(2),
},
Vector: &megaField.Vector{
X: pointy.Float32(10),
Y: pointy.Float32(11),
Z: pointy.Float32(12),
},
R: pointy.Float32(5),
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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\PutPositionByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->putPositionByUserId(
(new PutPositionByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-0001")
->withPosition((new Position())
->withX(0)
->withY(1)
->withZ(2)
)
->withVector((new Vector())
->withX(10)
->withY(11)
->withZ(12)
)
->withR(5)
->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.PutPositionByUserIdRequest;
import io.gs2.megaField.result.PutPositionByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
PutPositionByUserIdResult result = client.putPositionByUserId(
new PutPositionByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPosition(new Position()
.withX(0f)
.withY(1f)
.withZ(2f)
)
.withVector(new Vector()
.withX(10f)
.withY(11f)
.withZ(12f)
)
.withR(5f)
.withTimeOffsetToken(null)
);
Spatial 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.PutPositionByUserId(
new Gs2.Gs2MegaField.Request.PutPositionByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-0001")
.WithPosition(new Gs2.Gs2MegaField.Model.Position()
.WithX(0f)
.WithY(1f)
.WithZ(2f)
)
.WithVector(new Gs2.Gs2MegaField.Model.Vector()
.WithX(10f)
.WithY(11f)
.WithZ(12f)
)
.WithR(5f)
.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.putPositionByUserId(
new Gs2MegaField.PutPositionByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPosition(new Gs2MegaField.model.Position()
.withX(0)
.withY(1)
.withZ(2)
)
.withVector(new Gs2MegaField.model.Vector()
.withX(10)
.withY(11)
.withZ(12)
)
.withR(5)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.put_position_by_user_id(
mega_field.PutPositionByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
.with_position(mega_field.Position()
.with_x(0)
.with_y(1)
.with_z(2)
)
.with_vector(mega_field.Vector()
.with_x(10)
.with_y(11)
.with_z(12)
)
.with_r(5)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.put_position_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
position={
x=0,
y=1,
z=2,
},
vector={
x=10,
y=11,
z=12,
},
r=5,
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('mega_field')
api_result_handler = client.put_position_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
position={
x=0,
y=1,
z=2,
},
vector={
x=10,
y=11,
z=12,
},
r=5,
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;
```
---
### fetchPosition
좌표 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 이름 |
| userIds | List<string> | | ✓| | 1 ~ 100 items | 사용자 ID 리스트 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Spatial>](#spatial) | 물체 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.FetchPosition(
&mega_field.FetchPositionRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-0001"),
UserIds: []*string{
pointy.String("user-0001"),
pointy.String("user-0002"),
pointy.String("user-0003"),
},
}
)
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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\FetchPositionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->fetchPosition(
(new FetchPositionRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-0001")
->withUserIds([
"user-0001",
"user-0002",
"user-0003",
])
);
$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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.FetchPositionRequest;
import io.gs2.megaField.result.FetchPositionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
FetchPositionResult result = client.fetchPosition(
new FetchPositionRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withUserIds(Arrays.asList(
"user-0001",
"user-0002",
"user-0003"
))
);
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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.FetchPosition(
new Gs2.Gs2MegaField.Request.FetchPositionRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-0001")
.WithUserIds(new string[] {
"user-0001",
"user-0002",
"user-0003",
}),
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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.fetchPosition(
new Gs2MegaField.FetchPositionRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withUserIds([
"user-0001",
"user-0002",
"user-0003",
])
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.fetch_position(
mega_field.FetchPositionRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
.with_user_ids([
'user-0001',
'user-0002',
'user-0003',
])
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.fetch_position({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
userIds={
"user-0001",
"user-0002",
"user-0003"
},
})
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('mega_field')
api_result_handler = client.fetch_position_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
userIds={
"user-0001",
"user-0002",
"user-0003"
},
})
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;
```
---
### fetchPositionFromSystem
좌표 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 이름 |
| userIds | List<string> | | ✓| | 1 ~ 100 items | 사용자 ID 리스트 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Spatial>](#spatial) | 물체 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.FetchPositionFromSystem(
&mega_field.FetchPositionFromSystemRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-0001"),
UserIds: []*string{
pointy.String("user-0001"),
pointy.String("user-0002"),
pointy.String("user-0003"),
},
}
)
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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\FetchPositionFromSystemRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->fetchPositionFromSystem(
(new FetchPositionFromSystemRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-0001")
->withUserIds([
"user-0001",
"user-0002",
"user-0003",
])
);
$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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.FetchPositionFromSystemRequest;
import io.gs2.megaField.result.FetchPositionFromSystemResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
FetchPositionFromSystemResult result = client.fetchPositionFromSystem(
new FetchPositionFromSystemRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withUserIds(Arrays.asList(
"user-0001",
"user-0002",
"user-0003"
))
);
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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.FetchPositionFromSystem(
new Gs2.Gs2MegaField.Request.FetchPositionFromSystemRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-0001")
.WithUserIds(new string[] {
"user-0001",
"user-0002",
"user-0003",
}),
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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.fetchPositionFromSystem(
new Gs2MegaField.FetchPositionFromSystemRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withUserIds([
"user-0001",
"user-0002",
"user-0003",
])
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.fetch_position_from_system(
mega_field.FetchPositionFromSystemRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
.with_user_ids([
'user-0001',
'user-0002',
'user-0003',
])
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.fetch_position_from_system({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
userIds={
"user-0001",
"user-0002",
"user-0003"
},
})
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('mega_field')
api_result_handler = client.fetch_position_from_system_async({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
userIds={
"user-0001",
"user-0002",
"user-0003"
},
})
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;
```
---
### nearUserIds
근처에 있는 사용자 ID 리스트 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 이름 |
| point | [Position](#position) | | ✓| | | 좌표 |
| r | float | | ✓| | 1 ~ 16777214 | 반경 |
| limit | int | | ✓| | 1 ~ 100 | 최대 개수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | List<string> | 근처에 있는 사용자 ID 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.NearUserIds(
&mega_field.NearUserIdsRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-0001"),
Point: nil,
R: pointy.Float32(5),
Limit: 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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\NearUserIdsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->nearUserIds(
(new NearUserIdsRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-0001")
->withPoint(null)
->withR(5)
->withLimit(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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.NearUserIdsRequest;
import io.gs2.megaField.result.NearUserIdsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
NearUserIdsResult result = client.nearUserIds(
new NearUserIdsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPoint(null)
.withR(5f)
.withLimit(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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.NearUserIds(
new Gs2.Gs2MegaField.Request.NearUserIdsRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-0001")
.WithPoint(null)
.WithR(5f)
.WithLimit(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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.nearUserIds(
new Gs2MegaField.NearUserIdsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPoint(null)
.withR(5)
.withLimit(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.near_user_ids(
mega_field.NearUserIdsRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
.with_point(None)
.with_r(5)
.with_limit(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.near_user_ids({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
point=nil,
r=5,
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;
```
**GS2-Script(Async)**
```lua
client = gs2('mega_field')
api_result_handler = client.near_user_ids_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
point=nil,
r=5,
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;
```
---
### nearUserIdsFromSystem
근처에 있는 사용자 ID 리스트 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 이름 |
| point | [Position](#position) | | ✓| | | 좌표 |
| r | float | | ✓| | 1 ~ 16777214 | 반경 |
| limit | int | | ✓| | 1 ~ 100 | 최대 개수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | List<string> | 근처에 있는 사용자 ID 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.NearUserIdsFromSystem(
&mega_field.NearUserIdsFromSystemRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-0001"),
Point: nil,
R: pointy.Float32(5),
Limit: 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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\NearUserIdsFromSystemRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->nearUserIdsFromSystem(
(new NearUserIdsFromSystemRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-0001")
->withPoint(null)
->withR(5)
->withLimit(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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.NearUserIdsFromSystemRequest;
import io.gs2.megaField.result.NearUserIdsFromSystemResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
NearUserIdsFromSystemResult result = client.nearUserIdsFromSystem(
new NearUserIdsFromSystemRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPoint(null)
.withR(5f)
.withLimit(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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.NearUserIdsFromSystem(
new Gs2.Gs2MegaField.Request.NearUserIdsFromSystemRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-0001")
.WithPoint(null)
.WithR(5f)
.WithLimit(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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.nearUserIdsFromSystem(
new Gs2MegaField.NearUserIdsFromSystemRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPoint(null)
.withR(5)
.withLimit(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.near_user_ids_from_system(
mega_field.NearUserIdsFromSystemRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
.with_point(None)
.with_r(5)
.with_limit(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.near_user_ids_from_system({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
point=nil,
r=5,
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;
```
**GS2-Script(Async)**
```lua
client = gs2('mega_field')
api_result_handler = client.near_user_ids_from_system_async({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
point=nil,
r=5,
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;
```
---
### action
좌표 설정
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 이름 |
| position | [MyPosition](#myposition) | | ✓| | | 내 위치 정보 |
| scopes | [List<Scope>](#scope) | | | | 0 ~ 10 items | 다른 플레이어의 취득 범위 리스트 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Spatial>](#spatial) | 물체 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.Action(
&mega_field.ActionRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-0001"),
Position: nil,
Scopes: 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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\ActionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->action(
(new ActionRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-0001")
->withPosition(null)
->withScopes(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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.ActionRequest;
import io.gs2.megaField.result.ActionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
ActionResult result = client.action(
new ActionRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPosition(null)
.withScopes(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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.Action(
new Gs2.Gs2MegaField.Request.ActionRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-0001")
.WithPosition(null)
.WithScopes(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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.action(
new Gs2MegaField.ActionRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPosition(null)
.withScopes(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.action(
mega_field.ActionRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
.with_position(None)
.with_scopes(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.action({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
position=nil,
scopes=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('mega_field')
api_result_handler = client.action_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
position=nil,
scopes=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;
```
---
### actionByUserId
사용자 ID를 지정하여 좌표 설정
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 이름 |
| position | [MyPosition](#myposition) | | ✓| | | 내 위치 정보 |
| scopes | [List<Scope>](#scope) | | | | 0 ~ 10 items | 다른 플레이어의 취득 범위 리스트 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Spatial>](#spatial) | 물체 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.ActionByUserId(
&mega_field.ActionByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-0001"),
Position: nil,
Scopes: nil,
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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\ActionByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->actionByUserId(
(new ActionByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-0001")
->withPosition(null)
->withScopes(null)
->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.ActionByUserIdRequest;
import io.gs2.megaField.result.ActionByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
ActionByUserIdResult result = client.actionByUserId(
new ActionByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPosition(null)
.withScopes(null)
.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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.ActionByUserId(
new Gs2.Gs2MegaField.Request.ActionByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-0001")
.WithPosition(null)
.WithScopes(null)
.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.actionByUserId(
new Gs2MegaField.ActionByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withPosition(null)
.withScopes(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.action_by_user_id(
mega_field.ActionByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
.with_position(None)
.with_scopes(None)
.with_time_offset_token(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.action_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
position=nil,
scopes=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;
```
**GS2-Script(Async)**
```lua
client = gs2('mega_field')
api_result_handler = client.action_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
position=nil,
scopes=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;
```
---
### describeAreaModels
에어리어 모델 목록 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<AreaModel>](#areamodel) | 에어리어 모델 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.DescribeAreaModels(
&mega_field.DescribeAreaModelsRequest {
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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DescribeAreaModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->describeAreaModels(
(new DescribeAreaModelsRequest())
->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DescribeAreaModelsRequest;
import io.gs2.megaField.result.DescribeAreaModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
DescribeAreaModelsResult result = client.describeAreaModels(
new DescribeAreaModelsRequest()
.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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeAreaModels(
new Gs2.Gs2MegaField.Request.DescribeAreaModelsRequest()
.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.describeAreaModels(
new Gs2MegaField.DescribeAreaModelsRequest()
.withNamespaceName("namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.describe_area_models(
mega_field.DescribeAreaModelsRequest()
.with_namespace_name('namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.describe_area_models({
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('mega_field')
api_result_handler = client.describe_area_models_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;
```
---
### getAreaModel
에어리어 모델 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [AreaModel](#areamodel) | 에어리어 모델 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.GetAreaModel(
&mega_field.GetAreaModelRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetAreaModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->getAreaModel(
(new GetAreaModelRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetAreaModelRequest;
import io.gs2.megaField.result.GetAreaModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
GetAreaModelResult result = client.getAreaModel(
new GetAreaModelRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
);
AreaModel 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetAreaModel(
new Gs2.Gs2MegaField.Request.GetAreaModelRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.getAreaModel(
new Gs2MegaField.GetAreaModelRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.get_area_model(
mega_field.GetAreaModelRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.get_area_model({
namespaceName="namespace-0001",
areaModelName="area-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('mega_field')
api_result_handler = client.get_area_model_async({
namespaceName="namespace-0001",
areaModelName="area-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;
```
---
### describeLayerModels
레이어 모델 목록 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<LayerModel>](#layermodel) | 레이어 모델 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.DescribeLayerModels(
&mega_field.DescribeLayerModelsRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DescribeLayerModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->describeLayerModels(
(new DescribeLayerModelsRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DescribeLayerModelsRequest;
import io.gs2.megaField.result.DescribeLayerModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
DescribeLayerModelsResult result = client.describeLayerModels(
new DescribeLayerModelsRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeLayerModels(
new Gs2.Gs2MegaField.Request.DescribeLayerModelsRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.describeLayerModels(
new Gs2MegaField.DescribeLayerModelsRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.describe_layer_models(
mega_field.DescribeLayerModelsRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.describe_layer_models({
namespaceName="namespace-0001",
areaModelName="area-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('mega_field')
api_result_handler = client.describe_layer_models_async({
namespaceName="namespace-0001",
areaModelName="area-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;
```
---
### getLayerModel
레이어 모델 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 모델 이름 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [LayerModel](#layermodel) | 레이어 모델 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.GetLayerModel(
&mega_field.GetLayerModelRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetLayerModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->getLayerModel(
(new GetLayerModelRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetLayerModelRequest;
import io.gs2.megaField.result.GetLayerModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
GetLayerModelResult result = client.getLayerModel(
new GetLayerModelRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
);
LayerModel 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetLayerModel(
new Gs2.Gs2MegaField.Request.GetLayerModelRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.getLayerModel(
new Gs2MegaField.GetLayerModelRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.get_layer_model(
mega_field.GetLayerModelRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.get_layer_model({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-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('mega_field')
api_result_handler = client.get_layer_model_async({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-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;
```
---
### exportMaster
활성화 가능한 마스터 데이터 형식으로 모델 마스터 내보내기
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentFieldMaster](#currentfieldmaster) | 활성화 가능한 마스터 데이터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.ExportMaster(
&mega_field.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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\ExportMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.ExportMasterRequest;
import io.gs2.megaField.result.ExportMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
ExportMasterResult result = client.exportMaster(
new ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentFieldMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExportMaster(
new Gs2.Gs2MegaField.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.exportMaster(
new Gs2MegaField.ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.export_master(
mega_field.ExportMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
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('mega_field')
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;
```
---
### getCurrentFieldMaster
현재 활성화된 필드 모델의 마스터 데이터 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentFieldMaster](#currentfieldmaster) | 현재 활성화된 필드 모델의 마스터 데이터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.GetCurrentFieldMaster(
&mega_field.GetCurrentFieldMasterRequest {
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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetCurrentFieldMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->getCurrentFieldMaster(
(new GetCurrentFieldMasterRequest())
->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetCurrentFieldMasterRequest;
import io.gs2.megaField.result.GetCurrentFieldMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
GetCurrentFieldMasterResult result = client.getCurrentFieldMaster(
new GetCurrentFieldMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentFieldMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCurrentFieldMaster(
new Gs2.Gs2MegaField.Request.GetCurrentFieldMasterRequest()
.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.getCurrentFieldMaster(
new Gs2MegaField.GetCurrentFieldMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.get_current_field_master(
mega_field.GetCurrentFieldMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.get_current_field_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('mega_field')
api_result_handler = client.get_current_field_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;
```
---
### preUpdateCurrentFieldMaster
현재 활성화된 필드 모델의 마스터 데이터 업데이트(3단계 버전)
1MB를 초과하는 마스터 데이터를 업로드하는 경우, 3단계로 나누어 업데이트를 수행합니다.
1. 이 API를 실행하여 업로드용 토큰과 URL을 취득합니다.
2. 취득한 URL에 마스터 데이터를 업로드합니다.
3. UpdateCurrentFieldMaster에 업로드로 취득한 토큰을 전달하여 실행함으로써 마스터 데이터를 반영합니다.
#### 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/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.PreUpdateCurrentFieldMaster(
&mega_field.PreUpdateCurrentFieldMasterRequest {
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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\PreUpdateCurrentFieldMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->preUpdateCurrentFieldMaster(
(new PreUpdateCurrentFieldMasterRequest())
->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.PreUpdateCurrentFieldMasterRequest;
import io.gs2.megaField.result.PreUpdateCurrentFieldMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
PreUpdateCurrentFieldMasterResult result = client.preUpdateCurrentFieldMaster(
new PreUpdateCurrentFieldMasterRequest()
.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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.PreUpdateCurrentFieldMaster(
new Gs2.Gs2MegaField.Request.PreUpdateCurrentFieldMasterRequest()
.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.preUpdateCurrentFieldMaster(
new Gs2MegaField.PreUpdateCurrentFieldMasterRequest()
.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 mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.pre_update_current_field_master(
mega_field.PreUpdateCurrentFieldMasterRequest()
.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('mega_field')
api_result = client.pre_update_current_field_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('mega_field')
api_result_handler = client.pre_update_current_field_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;
```
---
### updateCurrentFieldMaster
현재 활성화된 필드 모델의 마스터 데이터 업데이트
#### 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 | [CurrentFieldMaster](#currentfieldmaster) | 업데이트된 현재 활성화된 필드 모델의 마스터 데이터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.UpdateCurrentFieldMaster(
&mega_field.UpdateCurrentFieldMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Mode: pointy.String("direct"),
Settings: pointy.String("{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_0001\"}]}]}"),
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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\UpdateCurrentFieldMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->updateCurrentFieldMaster(
(new UpdateCurrentFieldMasterRequest())
->withNamespaceName("namespace-0001")
->withMode("direct")
->withSettings("{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_0001\"}]}]}")
->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.UpdateCurrentFieldMasterRequest;
import io.gs2.megaField.result.UpdateCurrentFieldMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
UpdateCurrentFieldMasterResult result = client.updateCurrentFieldMaster(
new UpdateCurrentFieldMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_0001\"}]}]}")
.withUploadToken(null)
);
CurrentFieldMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentFieldMaster(
new Gs2.Gs2MegaField.Request.UpdateCurrentFieldMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMode("direct")
.WithSettings("{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_0001\"}]}]}")
.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.updateCurrentFieldMaster(
new Gs2MegaField.UpdateCurrentFieldMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_0001\"}]}]}")
.withUploadToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.update_current_field_master(
mega_field.UpdateCurrentFieldMasterRequest()
.with_namespace_name('namespace-0001')
.with_mode('direct')
.with_settings('{"version": "2022-08-28", "areaModels": [{"name": "area-0001", "metadata": "AREA_0001", "layerModels": [{"name": "layer-0001", "metadata": "LAYER_0001"}]}]}')
.with_upload_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.update_current_field_master({
namespaceName="namespace-0001",
mode="direct",
settings="{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_0001\"}]}]}",
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('mega_field')
api_result_handler = client.update_current_field_master_async({
namespaceName="namespace-0001",
mode="direct",
settings="{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_0001\"}]}]}",
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;
```
---
### updateCurrentFieldMasterFromGitHub
현재 활성화된 필드 모델의 마스터 데이터를 GitHub에서 업데이트
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| checkoutSetting | [GitHubCheckoutSetting](#githubcheckoutsetting) | | ✓| | | GitHub에서 마스터 데이터를 체크아웃하는 설정 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentFieldMaster](#currentfieldmaster) | 업데이트된 현재 활성화된 필드 모델의 마스터 데이터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.UpdateCurrentFieldMasterFromGitHub(
&mega_field.UpdateCurrentFieldMasterFromGitHubRequest {
NamespaceName: pointy.String("namespace-0001"),
CheckoutSetting: &megaField.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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\UpdateCurrentFieldMasterFromGitHubRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->updateCurrentFieldMasterFromGitHub(
(new UpdateCurrentFieldMasterFromGitHubRequest())
->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.UpdateCurrentFieldMasterFromGitHubRequest;
import io.gs2.megaField.result.UpdateCurrentFieldMasterFromGitHubResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
UpdateCurrentFieldMasterFromGitHubResult result = client.updateCurrentFieldMasterFromGitHub(
new UpdateCurrentFieldMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
CurrentFieldMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentFieldMasterFromGitHub(
new Gs2.Gs2MegaField.Request.UpdateCurrentFieldMasterFromGitHubRequest()
.WithNamespaceName("namespace-0001")
.WithCheckoutSetting(new Gs2.Gs2MegaField.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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.updateCurrentFieldMasterFromGitHub(
new Gs2MegaField.UpdateCurrentFieldMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new Gs2MegaField.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 mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.update_current_field_master_from_git_hub(
mega_field.UpdateCurrentFieldMasterFromGitHubRequest()
.with_namespace_name('namespace-0001')
.with_checkout_setting(mega_field.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('mega_field')
api_result = client.update_current_field_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('mega_field')
api_result_handler = client.update_current_field_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;
```
---
### describeAreaModelMasters
에어리어 모델 마스터 목록 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 조회한 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<AreaModelMaster>](#areamodelmaster) | 에어리어 모델 마스터 리스트 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.DescribeAreaModelMasters(
&mega_field.DescribeAreaModelMastersRequest {
NamespaceName: pointy.String("namespace-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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DescribeAreaModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->describeAreaModelMasters(
(new DescribeAreaModelMastersRequest())
->withNamespaceName("namespace-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DescribeAreaModelMastersRequest;
import io.gs2.megaField.result.DescribeAreaModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
DescribeAreaModelMastersResult result = client.describeAreaModelMasters(
new DescribeAreaModelMastersRequest()
.withNamespaceName("namespace-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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeAreaModelMasters(
new Gs2.Gs2MegaField.Request.DescribeAreaModelMastersRequest()
.WithNamespaceName("namespace-0001")
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.describeAreaModelMasters(
new Gs2MegaField.DescribeAreaModelMastersRequest()
.withNamespaceName("namespace-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 mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.describe_area_model_masters(
mega_field.DescribeAreaModelMastersRequest()
.with_namespace_name('namespace-0001')
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.describe_area_model_masters({
namespaceName="namespace-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('mega_field')
api_result_handler = client.describe_area_model_masters_async({
namespaceName="namespace-0001",
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createAreaModelMaster
에어리어 모델 마스터 신규 작성
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| name | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [AreaModelMaster](#areamodelmaster) | 생성한 에어리어 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.CreateAreaModelMaster(
&mega_field.CreateAreaModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("area-0001"),
Description: nil,
Metadata: 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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\CreateAreaModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->createAreaModelMaster(
(new CreateAreaModelMasterRequest())
->withNamespaceName("namespace-0001")
->withName("area-0001")
->withDescription(null)
->withMetadata(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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.CreateAreaModelMasterRequest;
import io.gs2.megaField.result.CreateAreaModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
CreateAreaModelMasterResult result = client.createAreaModelMaster(
new CreateAreaModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("area-0001")
.withDescription(null)
.withMetadata(null)
);
AreaModelMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateAreaModelMaster(
new Gs2.Gs2MegaField.Request.CreateAreaModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("area-0001")
.WithDescription(null)
.WithMetadata(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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.createAreaModelMaster(
new Gs2MegaField.CreateAreaModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("area-0001")
.withDescription(null)
.withMetadata(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.create_area_model_master(
mega_field.CreateAreaModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('area-0001')
.with_description(None)
.with_metadata(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.create_area_model_master({
namespaceName="namespace-0001",
name="area-0001",
description=nil,
metadata=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('mega_field')
api_result_handler = client.create_area_model_master_async({
namespaceName="namespace-0001",
name="area-0001",
description=nil,
metadata=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;
```
---
### getAreaModelMaster
에어리어 모델 마스터 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [AreaModelMaster](#areamodelmaster) | 에어리어 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.GetAreaModelMaster(
&mega_field.GetAreaModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetAreaModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->getAreaModelMaster(
(new GetAreaModelMasterRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetAreaModelMasterRequest;
import io.gs2.megaField.result.GetAreaModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
GetAreaModelMasterResult result = client.getAreaModelMaster(
new GetAreaModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
);
AreaModelMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetAreaModelMaster(
new Gs2.Gs2MegaField.Request.GetAreaModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.getAreaModelMaster(
new Gs2MegaField.GetAreaModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.get_area_model_master(
mega_field.GetAreaModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.get_area_model_master({
namespaceName="namespace-0001",
areaModelName="area-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('mega_field')
api_result_handler = client.get_area_model_master_async({
namespaceName="namespace-0001",
areaModelName="area-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;
```
---
### updateAreaModelMaster
에어리어 모델 마스터 업데이트
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [AreaModelMaster](#areamodelmaster) | 업데이트한 에어리어 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.UpdateAreaModelMaster(
&mega_field.UpdateAreaModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("AREA_MASTER"),
}
)
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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\UpdateAreaModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->updateAreaModelMaster(
(new UpdateAreaModelMasterRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-0001")
->withDescription("description1")
->withMetadata("AREA_MASTER")
);
$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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.UpdateAreaModelMasterRequest;
import io.gs2.megaField.result.UpdateAreaModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
UpdateAreaModelMasterResult result = client.updateAreaModelMaster(
new UpdateAreaModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withDescription("description1")
.withMetadata("AREA_MASTER")
);
AreaModelMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateAreaModelMaster(
new Gs2.Gs2MegaField.Request.UpdateAreaModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-0001")
.WithDescription("description1")
.WithMetadata("AREA_MASTER"),
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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.updateAreaModelMaster(
new Gs2MegaField.UpdateAreaModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withDescription("description1")
.withMetadata("AREA_MASTER")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.update_area_model_master(
mega_field.UpdateAreaModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
.with_description('description1')
.with_metadata('AREA_MASTER')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.update_area_model_master({
namespaceName="namespace-0001",
areaModelName="area-0001",
description="description1",
metadata="AREA_MASTER",
})
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('mega_field')
api_result_handler = client.update_area_model_master_async({
namespaceName="namespace-0001",
areaModelName="area-0001",
description="description1",
metadata="AREA_MASTER",
})
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;
```
---
### deleteAreaModelMaster
에어리어 모델 마스터 삭제
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [AreaModelMaster](#areamodelmaster) | 삭제한 에어리어 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.DeleteAreaModelMaster(
&mega_field.DeleteAreaModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DeleteAreaModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->deleteAreaModelMaster(
(new DeleteAreaModelMasterRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DeleteAreaModelMasterRequest;
import io.gs2.megaField.result.DeleteAreaModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
DeleteAreaModelMasterResult result = client.deleteAreaModelMaster(
new DeleteAreaModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
);
AreaModelMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteAreaModelMaster(
new Gs2.Gs2MegaField.Request.DeleteAreaModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.deleteAreaModelMaster(
new Gs2MegaField.DeleteAreaModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.delete_area_model_master(
mega_field.DeleteAreaModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.delete_area_model_master({
namespaceName="namespace-0001",
areaModelName="area-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('mega_field')
api_result_handler = client.delete_area_model_master_async({
namespaceName="namespace-0001",
areaModelName="area-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;
```
---
### describeLayerModelMasters
레이어 모델 마스터 목록 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 조회한 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<LayerModelMaster>](#layermodelmaster) | 레이어 모델 마스터 리스트 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.DescribeLayerModelMasters(
&mega_field.DescribeLayerModelMastersRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DescribeLayerModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->describeLayerModelMasters(
(new DescribeLayerModelMastersRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DescribeLayerModelMastersRequest;
import io.gs2.megaField.result.DescribeLayerModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
DescribeLayerModelMastersResult result = client.describeLayerModelMasters(
new DescribeLayerModelMastersRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeLayerModelMasters(
new Gs2.Gs2MegaField.Request.DescribeLayerModelMastersRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.describeLayerModelMasters(
new Gs2MegaField.DescribeLayerModelMastersRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-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 mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.describe_layer_model_masters(
mega_field.DescribeLayerModelMastersRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-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('mega_field')
api_result = client.describe_layer_model_masters({
namespaceName="namespace-0001",
areaModelName="area-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('mega_field')
api_result_handler = client.describe_layer_model_masters_async({
namespaceName="namespace-0001",
areaModelName="area-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;
```
---
### createLayerModelMaster
레이어 모델 마스터 신규 작성
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
| name | string | | ✓| | ~ 128자 | 레이어 모델 이름 |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [LayerModelMaster](#layermodelmaster) | 생성한 레이어 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.CreateLayerModelMaster(
&mega_field.CreateLayerModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-0001"),
Name: pointy.String("layer-0001"),
Description: nil,
Metadata: 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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\CreateLayerModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->createLayerModelMaster(
(new CreateLayerModelMasterRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-0001")
->withName("layer-0001")
->withDescription(null)
->withMetadata(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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.CreateLayerModelMasterRequest;
import io.gs2.megaField.result.CreateLayerModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
CreateLayerModelMasterResult result = client.createLayerModelMaster(
new CreateLayerModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withName("layer-0001")
.withDescription(null)
.withMetadata(null)
);
LayerModelMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateLayerModelMaster(
new Gs2.Gs2MegaField.Request.CreateLayerModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-0001")
.WithName("layer-0001")
.WithDescription(null)
.WithMetadata(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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.createLayerModelMaster(
new Gs2MegaField.CreateLayerModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withName("layer-0001")
.withDescription(null)
.withMetadata(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.create_layer_model_master(
mega_field.CreateLayerModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
.with_name('layer-0001')
.with_description(None)
.with_metadata(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.create_layer_model_master({
namespaceName="namespace-0001",
areaModelName="area-0001",
name="layer-0001",
description=nil,
metadata=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('mega_field')
api_result_handler = client.create_layer_model_master_async({
namespaceName="namespace-0001",
areaModelName="area-0001",
name="layer-0001",
description=nil,
metadata=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;
```
---
### getLayerModelMaster
레이어 모델 마스터 조회
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 모델 이름 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [LayerModelMaster](#layermodelmaster) | 레이어 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.GetLayerModelMaster(
&mega_field.GetLayerModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetLayerModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->getLayerModelMaster(
(new GetLayerModelMasterRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetLayerModelMasterRequest;
import io.gs2.megaField.result.GetLayerModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
GetLayerModelMasterResult result = client.getLayerModelMaster(
new GetLayerModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
);
LayerModelMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetLayerModelMaster(
new Gs2.Gs2MegaField.Request.GetLayerModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.getLayerModelMaster(
new Gs2MegaField.GetLayerModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.get_layer_model_master(
mega_field.GetLayerModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.get_layer_model_master({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-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('mega_field')
api_result_handler = client.get_layer_model_master_async({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-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;
```
---
### updateLayerModelMaster
레이어 모델 마스터 업데이트
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 모델 이름 |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [LayerModelMaster](#layermodelmaster) | 업데이트한 레이어 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.UpdateLayerModelMaster(
&mega_field.UpdateLayerModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("LAYER_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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\UpdateLayerModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->updateLayerModelMaster(
(new UpdateLayerModelMasterRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-0001")
->withDescription("description1")
->withMetadata("LAYER_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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.UpdateLayerModelMasterRequest;
import io.gs2.megaField.result.UpdateLayerModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
UpdateLayerModelMasterResult result = client.updateLayerModelMaster(
new UpdateLayerModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withDescription("description1")
.withMetadata("LAYER_0001")
);
LayerModelMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateLayerModelMaster(
new Gs2.Gs2MegaField.Request.UpdateLayerModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-0001")
.WithDescription("description1")
.WithMetadata("LAYER_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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.updateLayerModelMaster(
new Gs2MegaField.UpdateLayerModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
.withDescription("description1")
.withMetadata("LAYER_0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.update_layer_model_master(
mega_field.UpdateLayerModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
.with_description('description1')
.with_metadata('LAYER_0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.update_layer_model_master({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
description="description1",
metadata="LAYER_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('mega_field')
api_result_handler = client.update_layer_model_master_async({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-0001",
description="description1",
metadata="LAYER_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;
```
---
### deleteLayerModelMaster
레이어 모델 마스터 삭제
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| areaModelName | string | | ✓| | ~ 128자 | 에어리어 모델 이름 |
| layerModelName | string | | ✓| | ~ 128자 | 레이어 모델 이름 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [LayerModelMaster](#layermodelmaster) | 삭제한 레이어 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/megaField"
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 := mega_field.Gs2MegaFieldRestClient{
Session: &session,
}
result, err := client.DeleteLayerModelMaster(
&mega_field.DeleteLayerModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
AreaModelName: pointy.String("area-0001"),
LayerModelName: pointy.String("layer-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\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DeleteLayerModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2MegaFieldRestClient(
$session
);
try {
$result = $client->deleteLayerModelMaster(
(new DeleteLayerModelMasterRequest())
->withNamespaceName("namespace-0001")
->withAreaModelName("area-0001")
->withLayerModelName("layer-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DeleteLayerModelMasterRequest;
import io.gs2.megaField.result.DeleteLayerModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2MegaFieldRestClient client = new Gs2MegaFieldRestClient(session);
try {
DeleteLayerModelMasterResult result = client.deleteLayerModelMaster(
new DeleteLayerModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
);
LayerModelMaster 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 Gs2MegaFieldRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteLayerModelMaster(
new Gs2.Gs2MegaField.Request.DeleteLayerModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithAreaModelName("area-0001")
.WithLayerModelName("layer-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 Gs2MegaField from '@/gs2/megaField';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2MegaField.Gs2MegaFieldRestClient(session);
try {
const result = await client.deleteLayerModelMaster(
new Gs2MegaField.DeleteLayerModelMasterRequest()
.withNamespaceName("namespace-0001")
.withAreaModelName("area-0001")
.withLayerModelName("layer-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import mega_field
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = mega_field.Gs2MegaFieldRestClient(session)
try:
result = client.delete_layer_model_master(
mega_field.DeleteLayerModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_area_model_name('area-0001')
.with_layer_model_name('layer-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('mega_field')
api_result = client.delete_layer_model_master({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-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('mega_field')
api_result_handler = client.delete_layer_model_master_async({
namespaceName="namespace-0001",
areaModelName="area-0001",
layerModelName="layer-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;
```
---