GS2-Datastore

GS2 SDK Reference

Models

Namespace

Namespace is a mechanism that allows multiple uses of the same service for different purposes within a single project.
Basically, GS2 services have a layer called namespace, and different namespaces are treated as completely different data spaces, even for the same service.

Therefore, it is necessary to create a namespace before starting to use each service.

	Type	Description
namespaceId	string	Namespace GRN
name	string	Namespace name
description	string	description of Namespace
doneUploadScript	ScriptSetting	Script to be executed when reporting upload completion
logSetting	LogSetting	Log output settings
createdAt	long	Datetime of creation
updatedAt	long	Datetime of last update

ScriptSetting

	Type	Description
triggerScriptId	string	Script GRN
doneTriggerTargetType	enum ['none', 'gs2_script', 'aws']	Notification of Completion
doneTriggerScriptId	string	Script GRN
doneTriggerQueueNamespaceId	string	Namespace GRN

DataObject

Data Object

Data objects are data uploaded by game players.
Data is generation managed, with 30 days of historical data stored.

Access permissions can be set for the data.
There are three scopes: public, which can be accessed by anyone; protected, which can be accessed only by the game player with the specified user ID; and private, which can be accessed only by the game player himself.

	Type	Description
dataObjectId	string	Data object GRN
name	string	Data object Name
userId	string	User Id
scope	enum ['public', 'protected', 'private']	File access permission
allowUserIds	string[]	List of user IDs to be published
status	enum ['ACTIVE', 'UPLOADING', 'DELETED']	Status
generation	string	Data Generation
previousGeneration	string	Generation of previously valid data
createdAt	long	Datetime of creation
updatedAt	long	Datetime of last update

DataObjectHistory

Data Object History

You can check the update history of data objects.

	Type	Description
dataObjectHistoryId	string	History of Data object GRN
dataObjectName	string	Data object name
generation	string	Generations ID
contentLength	long	File size
createdAt	long	Datetime of creation

LogSetting

	Type	Description
loggingNamespaceId	string	Namespace GRN

Methods

describeNamespaces

describeNamespaces

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &datastore.DescribeNamespacesRequest {
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\DescribeNamespacesRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeNamespaces(
        (new DescribeNamespacesRequest())
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.DescribeNamespacesRequest;
import io.gs2.datastore.result.DescribeNamespacesResult;

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

try {
    DescribeNamespacesResult result = client.describeNamespaces(
        new DescribeNamespacesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    List<Namespace> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.DescribeNamespacesRequest;
using Gs2.Gs2Datastore.Result.DescribeNamespacesResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.DescribeNamespacesResult> asyncResult = null;
yield return client.DescribeNamespaces(
    new Gs2.Gs2Datastore.Request.DescribeNamespacesRequest()
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.describeNamespaces(
        new Gs2Datastore.DescribeNamespacesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

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

client = gs2('datastore')

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

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

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

Get list of namespaces

Request

	Type	Require	Default	Limitation	Description
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	Namespace[]	List of Namespace
nextPageToken	string	Page token to retrieve the rest of the listing

createNamespace

createNamespace

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &datastore.CreateNamespaceRequest {
        Name: pointy.String("namespace1"),
        Description: nil,
        LogSetting: &datastore.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"),
        },
        DoneUploadScript: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName(self::namespace1)
            ->withDescription(null)
            ->withLogSetting((new \Gs2\Datastore\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:\namespace1"))
            ->withDoneUploadScript(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.CreateNamespaceRequest;
import io.gs2.datastore.result.CreateNamespaceResult;

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

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withLogSetting(new io.gs2.datastore.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
            .withDoneUploadScript(null)
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.CreateNamespaceRequest;
using Gs2.Gs2Datastore.Result.CreateNamespaceResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2Datastore.Request.CreateNamespaceRequest()
        .WithName("namespace1")
        .WithDescription(null)
        .WithLogSetting(new Gs2.Gs2Datastore.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
        .WithDoneUploadScript(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.createNamespace(
        new Gs2Datastore.CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withLogSetting(new Gs2Datastore.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
            .withDoneUploadScript(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

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

client = gs2('datastore')

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

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

result = api_result.result
item = result.item;

Create a new namespace

Request

	Type	Require	Limitation	Description
name	string	✓	~ 32 chars	Namespace name
description	string		~ 1024 chars	description of Namespace
logSetting	LogSetting			Log output settings
doneUploadScript	ScriptSetting			Script to be executed when reporting upload completion

Result

	Type	Description
item	Namespace	Namespace created

getNamespaceStatus

getNamespaceStatus

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &datastore.GetNamespaceStatusRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
status := result.Status

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\GetNamespaceStatusRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespaceStatus(
        (new GetNamespaceStatusRequest())
            ->withNamespaceName(self::namespace1)
    );
    $status = $result->getStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.GetNamespaceStatusRequest;
import io.gs2.datastore.result.GetNamespaceStatusResult;

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

try {
    GetNamespaceStatusResult result = client.getNamespaceStatus(
        new GetNamespaceStatusRequest()
            .withNamespaceName("namespace1")
    );
    String status = result.getStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.GetNamespaceStatusRequest;
using Gs2.Gs2Datastore.Result.GetNamespaceStatusResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.GetNamespaceStatusResult> asyncResult = null;
yield return client.GetNamespaceStatus(
    new Gs2.Gs2Datastore.Request.GetNamespaceStatusRequest()
        .WithNamespaceName("namespace1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var status = result.Status;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.getNamespaceStatus(
        new Gs2Datastore.GetNamespaceStatusRequest()
            .withNamespaceName("namespace1")
    );
    const status = result.getStatus();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.get_namespace_status(
        datastore.GetNamespaceStatusRequest()
            .with_namespace_name(self.hash1)
    )
    status = result.status
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.get_namespace_status({
    namespaceName='namespace1',
})

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

result = api_result.result
status = result.status;

Get namespace status

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name

Result

	Type	Description
status	string

getNamespace

getNamespace

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &datastore.GetNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\GetNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespace(
        (new GetNamespaceRequest())
            ->withNamespaceName(self::namespace1)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.GetNamespaceRequest;
import io.gs2.datastore.result.GetNamespaceResult;

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

try {
    GetNamespaceResult result = client.getNamespace(
        new GetNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.GetNamespaceRequest;
using Gs2.Gs2Datastore.Result.GetNamespaceResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.GetNamespaceResult> asyncResult = null;
yield return client.GetNamespace(
    new Gs2.Gs2Datastore.Request.GetNamespaceRequest()
        .WithNamespaceName("namespace1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.getNamespace(
        new Gs2Datastore.GetNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.get_namespace(
        datastore.GetNamespaceRequest()
            .with_namespace_name(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.get_namespace({
    namespaceName='namespace1',
})

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

result = api_result.result
item = result.item;

Get namespace

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name

Result

	Type	Description
item	Namespace	Namespace

updateNamespace

updateNamespace

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &datastore.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
        Description: pointy.String("description1"),
        LogSetting: &datastore.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"),
        },
        DoneUploadScript: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName(self::namespace1)
            ->withDescription("description1")
            ->withLogSetting((new \Gs2\Datastore\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:\namespace1"))
            ->withDoneUploadScript(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.UpdateNamespaceRequest;
import io.gs2.datastore.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withLogSetting(new io.gs2.datastore.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
            .withDoneUploadScript(null)
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.UpdateNamespaceRequest;
using Gs2.Gs2Datastore.Result.UpdateNamespaceResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2Datastore.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace1")
        .WithDescription("description1")
        .WithLogSetting(new Gs2.Gs2Datastore.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
        .WithDoneUploadScript(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.updateNamespace(
        new Gs2Datastore.UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withLogSetting(new Gs2Datastore.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
            .withDoneUploadScript(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.update_namespace(
        datastore.UpdateNamespaceRequest()
            .with_namespace_name(self.hash1)
            .with_description('description1')
            .with_log_setting(
                datastore.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1'))
            .with_done_upload_script(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.update_namespace({
    namespaceName='namespace1',
    description='description1',
    logSetting={
        loggingNamespaceId='grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1',
    },
    doneUploadScript=nil,
})

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

result = api_result.result
item = result.item;

Update namespace

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 32 chars	Namespace name
description	string		~ 1024 chars	description of Namespace
logSetting	LogSetting			Log output settings
doneUploadScript	ScriptSetting			Script to be executed when reporting upload completion

Result

	Type	Description
item	Namespace	Updated namespace

deleteNamespace

deleteNamespace

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &datastore.DeleteNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\DeleteNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteNamespace(
        (new DeleteNamespaceRequest())
            ->withNamespaceName(self::namespace1)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.DeleteNamespaceRequest;
import io.gs2.datastore.result.DeleteNamespaceResult;

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

try {
    DeleteNamespaceResult result = client.deleteNamespace(
        new DeleteNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.DeleteNamespaceRequest;
using Gs2.Gs2Datastore.Result.DeleteNamespaceResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.DeleteNamespaceResult> asyncResult = null;
yield return client.DeleteNamespace(
    new Gs2.Gs2Datastore.Request.DeleteNamespaceRequest()
        .WithNamespaceName("namespace1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.deleteNamespace(
        new Gs2Datastore.DeleteNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.delete_namespace(
        datastore.DeleteNamespaceRequest()
            .with_namespace_name(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.delete_namespace({
    namespaceName='namespace1',
})

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

result = api_result.result
item = result.item;

Delete namespace

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name

Result

	Type	Description
item	Namespace	Deleted namespace

describeDataObjects

describeDataObjects

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.DescribeDataObjects(
    &datastore.DescribeDataObjectsRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        Status: pointy.String("ACTIVE"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\DescribeDataObjectsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeDataObjects(
        (new DescribeDataObjectsRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withStatus("ACTIVE")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.DescribeDataObjectsRequest;
import io.gs2.datastore.result.DescribeDataObjectsResult;

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

try {
    DescribeDataObjectsResult result = client.describeDataObjects(
        new DescribeDataObjectsRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withStatus("ACTIVE")
            .withPageToken(null)
            .withLimit(null)
    );
    List<DataObject> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.DescribeDataObjectsRequest;
using Gs2.Gs2Datastore.Result.DescribeDataObjectsResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.DescribeDataObjectsResult> asyncResult = null;
yield return client.DescribeDataObjects(
    new Gs2.Gs2Datastore.Request.DescribeDataObjectsRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001")
        .WithStatus("ACTIVE")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.describeDataObjects(
        new Gs2Datastore.DescribeDataObjectsRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withStatus("ACTIVE")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.describe_data_objects(
        datastore.DescribeDataObjectsRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_status('ACTIVE')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.describe_data_objects({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    status='ACTIVE',
    pageToken=nil,
    limit=nil,
})

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

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

Get list of data objects

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
status	enum ['ACTIVE', 'UPLOADING', 'DELETED']			~ 128 chars	Status
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	DataObject[]	List of Data object
nextPageToken	string	Page token to retrieve the rest of the listing

describeDataObjectsByUserId

describeDataObjectsByUserId

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.DescribeDataObjectsByUserId(
    &datastore.DescribeDataObjectsByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        Status: pointy.String("ACTIVE"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\DescribeDataObjectsByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeDataObjectsByUserId(
        (new DescribeDataObjectsByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withStatus("ACTIVE")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.DescribeDataObjectsByUserIdRequest;
import io.gs2.datastore.result.DescribeDataObjectsByUserIdResult;

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

try {
    DescribeDataObjectsByUserIdResult result = client.describeDataObjectsByUserId(
        new DescribeDataObjectsByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withStatus("ACTIVE")
            .withPageToken(null)
            .withLimit(null)
    );
    List<DataObject> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.DescribeDataObjectsByUserIdRequest;
using Gs2.Gs2Datastore.Result.DescribeDataObjectsByUserIdResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.DescribeDataObjectsByUserIdResult> asyncResult = null;
yield return client.DescribeDataObjectsByUserId(
    new Gs2.Gs2Datastore.Request.DescribeDataObjectsByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithStatus("ACTIVE")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.describeDataObjectsByUserId(
        new Gs2Datastore.DescribeDataObjectsByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withStatus("ACTIVE")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.describe_data_objects_by_user_id(
        datastore.DescribeDataObjectsByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_status('ACTIVE')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.describe_data_objects_by_user_id({
    namespaceName='namespace1',
    userId='user-0001',
    status='ACTIVE',
    pageToken=nil,
    limit=nil,
})

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

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

Obtain list of data objects by specifying the user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
status	enum ['ACTIVE', 'UPLOADING', 'DELETED']			~ 128 chars	Status
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	DataObject[]	List of Data object
nextPageToken	string	Page token to retrieve the rest of the listing

prepareUpload

prepareUpload

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareUpload(
    &datastore.PrepareUploadRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        Name: pointy.String("dataObject-0001"),
        ContentType: nil,
        Scope: pointy.String("public"),
        AllowUserIds: nil,
        UpdateIfExists: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
uploadUrl := result.UploadUrl

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareUploadRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareUpload(
        (new PrepareUploadRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withName("dataObject-0001")
            ->withContentType(null)
            ->withScope("public")
            ->withAllowUserIds(null)
            ->withUpdateIfExists(null)
    );
    $item = $result->getItem();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareUploadRequest;
import io.gs2.datastore.result.PrepareUploadResult;

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

try {
    PrepareUploadResult result = client.prepareUpload(
        new PrepareUploadRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withName("dataObject-0001")
            .withContentType(null)
            .withScope("public")
            .withAllowUserIds(null)
            .withUpdateIfExists(null)
    );
    DataObject item = result.getItem();
    String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareUploadRequest;
using Gs2.Gs2Datastore.Result.PrepareUploadResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareUploadResult> asyncResult = null;
yield return client.PrepareUpload(
    new Gs2.Gs2Datastore.Request.PrepareUploadRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001")
        .WithName("dataObject-0001")
        .WithContentType(null)
        .WithScope("public")
        .WithAllowUserIds(null)
        .WithUpdateIfExists(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var uploadUrl = result.UploadUrl;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareUpload(
        new Gs2Datastore.PrepareUploadRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withName("dataObject-0001")
            .withContentType(null)
            .withScope("public")
            .withAllowUserIds(null)
            .withUpdateIfExists(null)
    );
    const item = result.getItem();
    const uploadUrl = result.getUploadUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_upload(
        datastore.PrepareUploadRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_name('dataObject-0001')
            .with_content_type(None)
            .with_scope('public')
            .with_allow_user_ids(None)
            .with_update_if_exists(None)
    )
    item = result.item
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_upload({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    name='dataObject-0001',
    contentType=nil,
    scope='public',
    allowUserIds=nil,
    updateIfExists=nil,
})

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

result = api_result.result
item = result.item;
uploadUrl = result.uploadUrl;

Prepare to upload data objects

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
name	string			~ 128 chars	Data object name
contentType	string	✓	"application/octet-stream"	~ 256 chars	MIME-Type of the data to be uploaded
scope	enum ['public', 'protected', 'private']	✓	"private"	~ 128 chars	File access permission
allowUserIds	string[]	{scope} != none and {scope} == "protected"	[]		List of user IDs to be published
updateIfExists	bool	✓	false		Whether to raise an error if data already exists or to update the data

Result

	Type	Description
item	DataObject	Data object
uploadUrl	string	URL used to execute the upload process

prepareUploadByUserId

prepareUploadByUserId

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareUploadByUserId(
    &datastore.PrepareUploadByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        Name: pointy.String("dataObject-0001"),
        ContentType: nil,
        Scope: pointy.String("public"),
        AllowUserIds: nil,
        UpdateIfExists: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
uploadUrl := result.UploadUrl

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareUploadByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareUploadByUserId(
        (new PrepareUploadByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withName("dataObject-0001")
            ->withContentType(null)
            ->withScope("public")
            ->withAllowUserIds(null)
            ->withUpdateIfExists(null)
    );
    $item = $result->getItem();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareUploadByUserIdRequest;
import io.gs2.datastore.result.PrepareUploadByUserIdResult;

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

try {
    PrepareUploadByUserIdResult result = client.prepareUploadByUserId(
        new PrepareUploadByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withName("dataObject-0001")
            .withContentType(null)
            .withScope("public")
            .withAllowUserIds(null)
            .withUpdateIfExists(null)
    );
    DataObject item = result.getItem();
    String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareUploadByUserIdRequest;
using Gs2.Gs2Datastore.Result.PrepareUploadByUserIdResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareUploadByUserIdResult> asyncResult = null;
yield return client.PrepareUploadByUserId(
    new Gs2.Gs2Datastore.Request.PrepareUploadByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithName("dataObject-0001")
        .WithContentType(null)
        .WithScope("public")
        .WithAllowUserIds(null)
        .WithUpdateIfExists(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var uploadUrl = result.UploadUrl;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareUploadByUserId(
        new Gs2Datastore.PrepareUploadByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withName("dataObject-0001")
            .withContentType(null)
            .withScope("public")
            .withAllowUserIds(null)
            .withUpdateIfExists(null)
    );
    const item = result.getItem();
    const uploadUrl = result.getUploadUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_upload_by_user_id(
        datastore.PrepareUploadByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_name('dataObject-0001')
            .with_content_type(None)
            .with_scope('public')
            .with_allow_user_ids(None)
            .with_update_if_exists(None)
    )
    item = result.item
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_upload_by_user_id({
    namespaceName='namespace1',
    userId='user-0001',
    name='dataObject-0001',
    contentType=nil,
    scope='public',
    allowUserIds=nil,
    updateIfExists=nil,
})

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

result = api_result.result
item = result.item;
uploadUrl = result.uploadUrl;

Prepare to upload a data object by specifying a user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
name	string			~ 128 chars	Data object name
contentType	string	✓	"application/octet-stream"	~ 256 chars	MIME-Type of the data to be uploaded
scope	enum ['public', 'protected', 'private']	✓	"private"	~ 128 chars	File access permission
allowUserIds	string[]	{scope} != none and {scope} == "protected"	[]		List of user IDs to be published
updateIfExists	bool	✓	false		Whether to raise an error if data already exists or to update the data

Result

	Type	Description
item	DataObject	Data object
uploadUrl	string	URL used to execute the upload process

updateDataObject

updateDataObject

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.UpdateDataObject(
    &datastore.UpdateDataObjectRequest {
        NamespaceName: pointy.String("namespace1"),
        DataObjectName: pointy.String("dataObject-0001"),
        AccessToken: pointy.String("$access_token_0001"),
        Scope: pointy.String("public"),
        AllowUserIds: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\UpdateDataObjectRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateDataObject(
        (new UpdateDataObjectRequest())
            ->withNamespaceName(self::namespace1)
            ->withDataObjectName("dataObject-0001")
            ->withAccessToken(self::$accessToken0001)
            ->withScope("public")
            ->withAllowUserIds(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.UpdateDataObjectRequest;
import io.gs2.datastore.result.UpdateDataObjectResult;

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

try {
    UpdateDataObjectResult result = client.updateDataObject(
        new UpdateDataObjectRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withAccessToken("$access_token_0001")
            .withScope("public")
            .withAllowUserIds(null)
    );
    DataObject item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.UpdateDataObjectRequest;
using Gs2.Gs2Datastore.Result.UpdateDataObjectResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.UpdateDataObjectResult> asyncResult = null;
yield return client.UpdateDataObject(
    new Gs2.Gs2Datastore.Request.UpdateDataObjectRequest()
        .WithNamespaceName("namespace1")
        .WithDataObjectName("dataObject-0001")
        .WithAccessToken("$access_token_0001")
        .WithScope("public")
        .WithAllowUserIds(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.updateDataObject(
        new Gs2Datastore.UpdateDataObjectRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withAccessToken("$access_token_0001")
            .withScope("public")
            .withAllowUserIds(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.update_data_object(
        datastore.UpdateDataObjectRequest()
            .with_namespace_name(self.hash1)
            .with_data_object_name('dataObject-0001')
            .with_access_token(self.access_token_0001)
            .with_scope('public')
            .with_allow_user_ids(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.update_data_object({
    namespaceName='namespace1',
    dataObjectName='dataObject-0001',
    accessToken='$access_token_0001',
    scope='public',
    allowUserIds=nil,
})

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

result = api_result.result
item = result.item;

Update data objects

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name
accessToken	string	✓		~ 128 chars	User Id
scope	enum ['public', 'protected', 'private']	✓	"private"	~ 128 chars	File access permission
allowUserIds	string[]	{scope} != none and {scope} == "protected"	[]		List of user IDs to be published

Result

	Type	Description
item	DataObject	Data object

updateDataObjectByUserId

updateDataObjectByUserId

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.UpdateDataObjectByUserId(
    &datastore.UpdateDataObjectByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        DataObjectName: pointy.String("dataObject-0001"),
        UserId: pointy.String("user-0001"),
        Scope: pointy.String("public"),
        AllowUserIds: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\UpdateDataObjectByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateDataObjectByUserId(
        (new UpdateDataObjectByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withDataObjectName("dataObject-0001")
            ->withUserId("user-0001")
            ->withScope("public")
            ->withAllowUserIds(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.UpdateDataObjectByUserIdRequest;
import io.gs2.datastore.result.UpdateDataObjectByUserIdResult;

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

try {
    UpdateDataObjectByUserIdResult result = client.updateDataObjectByUserId(
        new UpdateDataObjectByUserIdRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withUserId("user-0001")
            .withScope("public")
            .withAllowUserIds(null)
    );
    DataObject item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.UpdateDataObjectByUserIdRequest;
using Gs2.Gs2Datastore.Result.UpdateDataObjectByUserIdResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.UpdateDataObjectByUserIdResult> asyncResult = null;
yield return client.UpdateDataObjectByUserId(
    new Gs2.Gs2Datastore.Request.UpdateDataObjectByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithDataObjectName("dataObject-0001")
        .WithUserId("user-0001")
        .WithScope("public")
        .WithAllowUserIds(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.updateDataObjectByUserId(
        new Gs2Datastore.UpdateDataObjectByUserIdRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withUserId("user-0001")
            .withScope("public")
            .withAllowUserIds(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.update_data_object_by_user_id(
        datastore.UpdateDataObjectByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_data_object_name('dataObject-0001')
            .with_user_id('user-0001')
            .with_scope('public')
            .with_allow_user_ids(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.update_data_object_by_user_id({
    namespaceName='namespace1',
    dataObjectName='dataObject-0001',
    userId='user-0001',
    scope='public',
    allowUserIds=nil,
})

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

result = api_result.result
item = result.item;

Update data object with user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name
userId	string	✓		~ 128 chars	User Id
scope	enum ['public', 'protected', 'private']	✓	"private"	~ 128 chars	File access permission
allowUserIds	string[]	{scope} != none and {scope} == "protected"	[]		List of user IDs to be published

Result

	Type	Description
item	DataObject	Data object

prepareReUpload

prepareReUpload

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareReUpload(
    &datastore.PrepareReUploadRequest {
        NamespaceName: pointy.String("namespace1"),
        DataObjectName: pointy.String("dataObject-0001"),
        AccessToken: pointy.String("$access_token_0001"),
        ContentType: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
uploadUrl := result.UploadUrl

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareReUploadRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareReUpload(
        (new PrepareReUploadRequest())
            ->withNamespaceName(self::namespace1)
            ->withDataObjectName("dataObject-0001")
            ->withAccessToken(self::$accessToken0001)
            ->withContentType(null)
    );
    $item = $result->getItem();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareReUploadRequest;
import io.gs2.datastore.result.PrepareReUploadResult;

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

try {
    PrepareReUploadResult result = client.prepareReUpload(
        new PrepareReUploadRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withAccessToken("$access_token_0001")
            .withContentType(null)
    );
    DataObject item = result.getItem();
    String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareReUploadRequest;
using Gs2.Gs2Datastore.Result.PrepareReUploadResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareReUploadResult> asyncResult = null;
yield return client.PrepareReUpload(
    new Gs2.Gs2Datastore.Request.PrepareReUploadRequest()
        .WithNamespaceName("namespace1")
        .WithDataObjectName("dataObject-0001")
        .WithAccessToken("$access_token_0001")
        .WithContentType(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var uploadUrl = result.UploadUrl;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareReUpload(
        new Gs2Datastore.PrepareReUploadRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withAccessToken("$access_token_0001")
            .withContentType(null)
    );
    const item = result.getItem();
    const uploadUrl = result.getUploadUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_re_upload(
        datastore.PrepareReUploadRequest()
            .with_namespace_name(self.hash1)
            .with_data_object_name('dataObject-0001')
            .with_access_token(self.access_token_0001)
            .with_content_type(None)
    )
    item = result.item
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_re_upload({
    namespaceName='namespace1',
    dataObjectName='dataObject-0001',
    accessToken='$access_token_0001',
    contentType=nil,
})

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

result = api_result.result
item = result.item;
uploadUrl = result.uploadUrl;

Prepare to re-upload data objects

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name
accessToken	string	✓		~ 128 chars	User Id
contentType	string	✓	"application/octet-stream"	~ 256 chars	MIME-Type of the data to be uploaded

Result

	Type	Description
item	DataObject	Data object
uploadUrl	string	URL used to execute the upload process

prepareReUploadByUserId

prepareReUploadByUserId

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareReUploadByUserId(
    &datastore.PrepareReUploadByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        DataObjectName: pointy.String("dataObject-0001"),
        UserId: pointy.String("user-0001"),
        ContentType: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
uploadUrl := result.UploadUrl

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareReUploadByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareReUploadByUserId(
        (new PrepareReUploadByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withDataObjectName("dataObject-0001")
            ->withUserId("user-0001")
            ->withContentType(null)
    );
    $item = $result->getItem();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareReUploadByUserIdRequest;
import io.gs2.datastore.result.PrepareReUploadByUserIdResult;

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

try {
    PrepareReUploadByUserIdResult result = client.prepareReUploadByUserId(
        new PrepareReUploadByUserIdRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withUserId("user-0001")
            .withContentType(null)
    );
    DataObject item = result.getItem();
    String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareReUploadByUserIdRequest;
using Gs2.Gs2Datastore.Result.PrepareReUploadByUserIdResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareReUploadByUserIdResult> asyncResult = null;
yield return client.PrepareReUploadByUserId(
    new Gs2.Gs2Datastore.Request.PrepareReUploadByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithDataObjectName("dataObject-0001")
        .WithUserId("user-0001")
        .WithContentType(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var uploadUrl = result.UploadUrl;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareReUploadByUserId(
        new Gs2Datastore.PrepareReUploadByUserIdRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withUserId("user-0001")
            .withContentType(null)
    );
    const item = result.getItem();
    const uploadUrl = result.getUploadUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_re_upload_by_user_id(
        datastore.PrepareReUploadByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_data_object_name('dataObject-0001')
            .with_user_id('user-0001')
            .with_content_type(None)
    )
    item = result.item
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_re_upload_by_user_id({
    namespaceName='namespace1',
    dataObjectName='dataObject-0001',
    userId='user-0001',
    contentType=nil,
})

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

result = api_result.result
item = result.item;
uploadUrl = result.uploadUrl;

Prepare to re-upload data objects

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name
userId	string	✓		~ 128 chars	User Id
contentType	string	✓	"application/octet-stream"	~ 256 chars	MIME-Type of the data to be uploaded

Result

	Type	Description
item	DataObject	Data object
uploadUrl	string	URL used to execute the upload process

doneUpload

doneUpload

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.DoneUpload(
    &datastore.DoneUploadRequest {
        NamespaceName: pointy.String("namespace1"),
        DataObjectName: pointy.String("dataObject-0001"),
        AccessToken: pointy.String("$access_token_0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\DoneUploadRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->doneUpload(
        (new DoneUploadRequest())
            ->withNamespaceName(self::namespace1)
            ->withDataObjectName("dataObject-0001")
            ->withAccessToken(self::$accessToken0001)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.DoneUploadRequest;
import io.gs2.datastore.result.DoneUploadResult;

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

try {
    DoneUploadResult result = client.doneUpload(
        new DoneUploadRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withAccessToken("$access_token_0001")
    );
    DataObject item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.DoneUploadRequest;
using Gs2.Gs2Datastore.Result.DoneUploadResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.DoneUploadResult> asyncResult = null;
yield return client.DoneUpload(
    new Gs2.Gs2Datastore.Request.DoneUploadRequest()
        .WithNamespaceName("namespace1")
        .WithDataObjectName("dataObject-0001")
        .WithAccessToken("$access_token_0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.doneUpload(
        new Gs2Datastore.DoneUploadRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withAccessToken("$access_token_0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.done_upload(
        datastore.DoneUploadRequest()
            .with_namespace_name(self.hash1)
            .with_data_object_name('dataObject-0001')
            .with_access_token(self.access_token_0001)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.done_upload({
    namespaceName='namespace1',
    dataObjectName='dataObject-0001',
    accessToken='$access_token_0001',
})

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

result = api_result.result
item = result.item;

Report completion of data object upload

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name
accessToken	string	✓		~ 128 chars	User Id

Result

	Type	Description
item	DataObject	Data object

doneUploadByUserId

doneUploadByUserId

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.DoneUploadByUserId(
    &datastore.DoneUploadByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        DataObjectName: pointy.String("dataObject-0001"),
        UserId: pointy.String("user-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\DoneUploadByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->doneUploadByUserId(
        (new DoneUploadByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withDataObjectName("dataObject-0001")
            ->withUserId("user-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.DoneUploadByUserIdRequest;
import io.gs2.datastore.result.DoneUploadByUserIdResult;

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

try {
    DoneUploadByUserIdResult result = client.doneUploadByUserId(
        new DoneUploadByUserIdRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withUserId("user-0001")
    );
    DataObject item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.DoneUploadByUserIdRequest;
using Gs2.Gs2Datastore.Result.DoneUploadByUserIdResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.DoneUploadByUserIdResult> asyncResult = null;
yield return client.DoneUploadByUserId(
    new Gs2.Gs2Datastore.Request.DoneUploadByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithDataObjectName("dataObject-0001")
        .WithUserId("user-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.doneUploadByUserId(
        new Gs2Datastore.DoneUploadByUserIdRequest()
            .withNamespaceName("namespace1")
            .withDataObjectName("dataObject-0001")
            .withUserId("user-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.done_upload_by_user_id(
        datastore.DoneUploadByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_data_object_name('dataObject-0001')
            .with_user_id('user-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.done_upload_by_user_id({
    namespaceName='namespace1',
    dataObjectName='dataObject-0001',
    userId='user-0001',
})

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

result = api_result.result
item = result.item;

Report completion of data object upload by specifying user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name
userId	string	✓		~ 128 chars	User Id

Result

	Type	Description
item	DataObject	Data object

deleteDataObject

deleteDataObject

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.DeleteDataObject(
    &datastore.DeleteDataObjectRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        DataObjectName: pointy.String("dataObject-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\DeleteDataObjectRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteDataObject(
        (new DeleteDataObjectRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withDataObjectName("dataObject-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.DeleteDataObjectRequest;
import io.gs2.datastore.result.DeleteDataObjectResult;

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

try {
    DeleteDataObjectResult result = client.deleteDataObject(
        new DeleteDataObjectRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectName("dataObject-0001")
    );
    DataObject item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.DeleteDataObjectRequest;
using Gs2.Gs2Datastore.Result.DeleteDataObjectResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.DeleteDataObjectResult> asyncResult = null;
yield return client.DeleteDataObject(
    new Gs2.Gs2Datastore.Request.DeleteDataObjectRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001")
        .WithDataObjectName("dataObject-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.deleteDataObject(
        new Gs2Datastore.DeleteDataObjectRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectName("dataObject-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.delete_data_object(
        datastore.DeleteDataObjectRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_data_object_name('dataObject-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.delete_data_object({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    dataObjectName='dataObject-0001',
})

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

result = api_result.result
item = result.item;

Deleting data objects

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name

Result

	Type	Description
item	DataObject	Data object

deleteDataObjectByUserId

deleteDataObjectByUserId

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.DeleteDataObjectByUserId(
    &datastore.DeleteDataObjectByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        DataObjectName: pointy.String("dataObject-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\DeleteDataObjectByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteDataObjectByUserId(
        (new DeleteDataObjectByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withDataObjectName("dataObject-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.DeleteDataObjectByUserIdRequest;
import io.gs2.datastore.result.DeleteDataObjectByUserIdResult;

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

try {
    DeleteDataObjectByUserIdResult result = client.deleteDataObjectByUserId(
        new DeleteDataObjectByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withDataObjectName("dataObject-0001")
    );
    DataObject item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.DeleteDataObjectByUserIdRequest;
using Gs2.Gs2Datastore.Result.DeleteDataObjectByUserIdResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.DeleteDataObjectByUserIdResult> asyncResult = null;
yield return client.DeleteDataObjectByUserId(
    new Gs2.Gs2Datastore.Request.DeleteDataObjectByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithDataObjectName("dataObject-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.deleteDataObjectByUserId(
        new Gs2Datastore.DeleteDataObjectByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withDataObjectName("dataObject-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.delete_data_object_by_user_id(
        datastore.DeleteDataObjectByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_data_object_name('dataObject-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.delete_data_object_by_user_id({
    namespaceName='namespace1',
    userId='user-0001',
    dataObjectName='dataObject-0001',
})

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

result = api_result.result
item = result.item;

Delete a data object by specifying a user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name

Result

	Type	Description
item	DataObject	Data object

prepareDownload

prepareDownload

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareDownload(
    &datastore.PrepareDownloadRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        DataObjectId: pointy.String("grn:dataObject-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
fileUrl := result.FileUrl
contentLength := result.ContentLength

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareDownloadRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareDownload(
        (new PrepareDownloadRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withDataObjectId("grn:dataObject-0001")
    );
    $item = $result->getItem();
    $fileUrl = $result->getFileUrl();
    $contentLength = $result->getContentLength();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareDownloadRequest;
import io.gs2.datastore.result.PrepareDownloadResult;

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

try {
    PrepareDownloadResult result = client.prepareDownload(
        new PrepareDownloadRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectId("grn:dataObject-0001")
    );
    DataObject item = result.getItem();
    String fileUrl = result.getFileUrl();
    long contentLength = result.getContentLength();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareDownloadRequest;
using Gs2.Gs2Datastore.Result.PrepareDownloadResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareDownloadResult> asyncResult = null;
yield return client.PrepareDownload(
    new Gs2.Gs2Datastore.Request.PrepareDownloadRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001")
        .WithDataObjectId("grn:dataObject-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var fileUrl = result.FileUrl;
var contentLength = result.ContentLength;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareDownload(
        new Gs2Datastore.PrepareDownloadRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectId("grn:dataObject-0001")
    );
    const item = result.getItem();
    const fileUrl = result.getFileUrl();
    const contentLength = result.getContentLength();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_download(
        datastore.PrepareDownloadRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_data_object_id('grn:dataObject-0001')
    )
    item = result.item
    file_url = result.file_url
    content_length = result.content_length
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_download({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    dataObjectId='grn:dataObject-0001',
})

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

result = api_result.result
item = result.item;
fileUrl = result.fileUrl;
contentLength = result.contentLength;

Prepare data objects for download

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 32 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
dataObjectId	string	✓	~ 1024 chars	Data object GRN

Result

	Type	Description
item	DataObject	Data object
fileUrl	string	URL to download the file
contentLength	long	File size

prepareDownloadByUserId

prepareDownloadByUserId

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareDownloadByUserId(
    &datastore.PrepareDownloadByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        DataObjectId: pointy.String("grn:dataObject-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
fileUrl := result.FileUrl
contentLength := result.ContentLength

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareDownloadByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareDownloadByUserId(
        (new PrepareDownloadByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withDataObjectId("grn:dataObject-0001")
    );
    $item = $result->getItem();
    $fileUrl = $result->getFileUrl();
    $contentLength = $result->getContentLength();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareDownloadByUserIdRequest;
import io.gs2.datastore.result.PrepareDownloadByUserIdResult;

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

try {
    PrepareDownloadByUserIdResult result = client.prepareDownloadByUserId(
        new PrepareDownloadByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withDataObjectId("grn:dataObject-0001")
    );
    DataObject item = result.getItem();
    String fileUrl = result.getFileUrl();
    long contentLength = result.getContentLength();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareDownloadByUserIdRequest;
using Gs2.Gs2Datastore.Result.PrepareDownloadByUserIdResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareDownloadByUserIdResult> asyncResult = null;
yield return client.PrepareDownloadByUserId(
    new Gs2.Gs2Datastore.Request.PrepareDownloadByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithDataObjectId("grn:dataObject-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var fileUrl = result.FileUrl;
var contentLength = result.ContentLength;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareDownloadByUserId(
        new Gs2Datastore.PrepareDownloadByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withDataObjectId("grn:dataObject-0001")
    );
    const item = result.getItem();
    const fileUrl = result.getFileUrl();
    const contentLength = result.getContentLength();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_download_by_user_id(
        datastore.PrepareDownloadByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_data_object_id('grn:dataObject-0001')
    )
    item = result.item
    file_url = result.file_url
    content_length = result.content_length
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_download_by_user_id({
    namespaceName='namespace1',
    userId='user-0001',
    dataObjectId='grn:dataObject-0001',
})

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

result = api_result.result
item = result.item;
fileUrl = result.fileUrl;
contentLength = result.contentLength;

Prepare data object for download by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 32 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
dataObjectId	string	✓	~ 1024 chars	Data object GRN

Result

	Type	Description
item	DataObject	Data object
fileUrl	string	URL to download the file
contentLength	long	File size

prepareDownloadByGeneration

prepareDownloadByGeneration

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareDownloadByGeneration(
    &datastore.PrepareDownloadByGenerationRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        DataObjectId: pointy.String("grn:dataObject-0001"),
        Generation: pointy.String("generation-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
fileUrl := result.FileUrl
contentLength := result.ContentLength

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareDownloadByGenerationRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareDownloadByGeneration(
        (new PrepareDownloadByGenerationRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withDataObjectId("grn:dataObject-0001")
            ->withGeneration("generation-0001")
    );
    $item = $result->getItem();
    $fileUrl = $result->getFileUrl();
    $contentLength = $result->getContentLength();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareDownloadByGenerationRequest;
import io.gs2.datastore.result.PrepareDownloadByGenerationResult;

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

try {
    PrepareDownloadByGenerationResult result = client.prepareDownloadByGeneration(
        new PrepareDownloadByGenerationRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectId("grn:dataObject-0001")
            .withGeneration("generation-0001")
    );
    DataObject item = result.getItem();
    String fileUrl = result.getFileUrl();
    long contentLength = result.getContentLength();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareDownloadByGenerationRequest;
using Gs2.Gs2Datastore.Result.PrepareDownloadByGenerationResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareDownloadByGenerationResult> asyncResult = null;
yield return client.PrepareDownloadByGeneration(
    new Gs2.Gs2Datastore.Request.PrepareDownloadByGenerationRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001")
        .WithDataObjectId("grn:dataObject-0001")
        .WithGeneration("generation-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var fileUrl = result.FileUrl;
var contentLength = result.ContentLength;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareDownloadByGeneration(
        new Gs2Datastore.PrepareDownloadByGenerationRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectId("grn:dataObject-0001")
            .withGeneration("generation-0001")
    );
    const item = result.getItem();
    const fileUrl = result.getFileUrl();
    const contentLength = result.getContentLength();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_download_by_generation(
        datastore.PrepareDownloadByGenerationRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_data_object_id('grn:dataObject-0001')
            .with_generation('generation-0001')
    )
    item = result.item
    file_url = result.file_url
    content_length = result.content_length
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_download_by_generation({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    dataObjectId='grn:dataObject-0001',
    generation='generation-0001',
})

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

result = api_result.result
item = result.item;
fileUrl = result.fileUrl;
contentLength = result.contentLength;

Prepare data objects for download by specifying the generation

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 32 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
dataObjectId	string	✓	~ 1024 chars	Data object GRN
generation	string	✓	~ 128 chars	Data Generation

Result

	Type	Description
item	DataObject	Data object
fileUrl	string	URL to download the file
contentLength	long	File size

prepareDownloadByGenerationAndUserId

prepareDownloadByGenerationAndUserId

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareDownloadByGenerationAndUserId(
    &datastore.PrepareDownloadByGenerationAndUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        DataObjectId: pointy.String("grn:dataObject-0001"),
        Generation: pointy.String("generation-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
fileUrl := result.FileUrl
contentLength := result.ContentLength

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareDownloadByGenerationAndUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareDownloadByGenerationAndUserId(
        (new PrepareDownloadByGenerationAndUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withDataObjectId("grn:dataObject-0001")
            ->withGeneration("generation-0001")
    );
    $item = $result->getItem();
    $fileUrl = $result->getFileUrl();
    $contentLength = $result->getContentLength();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareDownloadByGenerationAndUserIdRequest;
import io.gs2.datastore.result.PrepareDownloadByGenerationAndUserIdResult;

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

try {
    PrepareDownloadByGenerationAndUserIdResult result = client.prepareDownloadByGenerationAndUserId(
        new PrepareDownloadByGenerationAndUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withDataObjectId("grn:dataObject-0001")
            .withGeneration("generation-0001")
    );
    DataObject item = result.getItem();
    String fileUrl = result.getFileUrl();
    long contentLength = result.getContentLength();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareDownloadByGenerationAndUserIdRequest;
using Gs2.Gs2Datastore.Result.PrepareDownloadByGenerationAndUserIdResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareDownloadByGenerationAndUserIdResult> asyncResult = null;
yield return client.PrepareDownloadByGenerationAndUserId(
    new Gs2.Gs2Datastore.Request.PrepareDownloadByGenerationAndUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithDataObjectId("grn:dataObject-0001")
        .WithGeneration("generation-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var fileUrl = result.FileUrl;
var contentLength = result.ContentLength;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareDownloadByGenerationAndUserId(
        new Gs2Datastore.PrepareDownloadByGenerationAndUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withDataObjectId("grn:dataObject-0001")
            .withGeneration("generation-0001")
    );
    const item = result.getItem();
    const fileUrl = result.getFileUrl();
    const contentLength = result.getContentLength();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_download_by_generation_and_user_id(
        datastore.PrepareDownloadByGenerationAndUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_data_object_id('grn:dataObject-0001')
            .with_generation('generation-0001')
    )
    item = result.item
    file_url = result.file_url
    content_length = result.content_length
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_download_by_generation_and_user_id({
    namespaceName='namespace1',
    userId='user-0001',
    dataObjectId='grn:dataObject-0001',
    generation='generation-0001',
})

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

result = api_result.result
item = result.item;
fileUrl = result.fileUrl;
contentLength = result.contentLength;

Prepare data object for download by specifying user ID and generation

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 32 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
dataObjectId	string	✓	~ 1024 chars	Data object GRN
generation	string	✓	~ 128 chars	Data Generation

Result

	Type	Description
item	DataObject	Data object
fileUrl	string	URL to download the file
contentLength	long	File size

prepareDownloadOwnData

prepareDownloadOwnData

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareDownloadOwnData(
    &datastore.PrepareDownloadOwnDataRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        DataObjectName: pointy.String("dataObject-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
fileUrl := result.FileUrl
contentLength := result.ContentLength

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareDownloadOwnDataRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareDownloadOwnData(
        (new PrepareDownloadOwnDataRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withDataObjectName("dataObject-0001")
    );
    $item = $result->getItem();
    $fileUrl = $result->getFileUrl();
    $contentLength = $result->getContentLength();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareDownloadOwnDataRequest;
import io.gs2.datastore.result.PrepareDownloadOwnDataResult;

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

try {
    PrepareDownloadOwnDataResult result = client.prepareDownloadOwnData(
        new PrepareDownloadOwnDataRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectName("dataObject-0001")
    );
    DataObject item = result.getItem();
    String fileUrl = result.getFileUrl();
    long contentLength = result.getContentLength();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareDownloadOwnDataRequest;
using Gs2.Gs2Datastore.Result.PrepareDownloadOwnDataResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareDownloadOwnDataResult> asyncResult = null;
yield return client.PrepareDownloadOwnData(
    new Gs2.Gs2Datastore.Request.PrepareDownloadOwnDataRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001")
        .WithDataObjectName("dataObject-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var fileUrl = result.FileUrl;
var contentLength = result.ContentLength;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareDownloadOwnData(
        new Gs2Datastore.PrepareDownloadOwnDataRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectName("dataObject-0001")
    );
    const item = result.getItem();
    const fileUrl = result.getFileUrl();
    const contentLength = result.getContentLength();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_download_own_data(
        datastore.PrepareDownloadOwnDataRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_data_object_name('dataObject-0001')
    )
    item = result.item
    file_url = result.file_url
    content_length = result.content_length
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_download_own_data({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    dataObjectName='dataObject-0001',
})

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

result = api_result.result
item = result.item;
fileUrl = result.fileUrl;
contentLength = result.contentLength;

Prepare data objects for download

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name

Result

	Type	Description
item	DataObject	Data object
fileUrl	string	URL to download the file
contentLength	long	File size

prepareDownloadByUserIdAndDataObjectName

prepareDownloadByUserIdAndDataObjectName

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareDownloadByUserIdAndDataObjectName(
    &datastore.PrepareDownloadByUserIdAndDataObjectNameRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        DataObjectName: pointy.String("dataObject-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
fileUrl := result.FileUrl
contentLength := result.ContentLength

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareDownloadByUserIdAndDataObjectNameRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareDownloadByUserIdAndDataObjectName(
        (new PrepareDownloadByUserIdAndDataObjectNameRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withDataObjectName("dataObject-0001")
    );
    $item = $result->getItem();
    $fileUrl = $result->getFileUrl();
    $contentLength = $result->getContentLength();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareDownloadByUserIdAndDataObjectNameRequest;
import io.gs2.datastore.result.PrepareDownloadByUserIdAndDataObjectNameResult;

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

try {
    PrepareDownloadByUserIdAndDataObjectNameResult result = client.prepareDownloadByUserIdAndDataObjectName(
        new PrepareDownloadByUserIdAndDataObjectNameRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withDataObjectName("dataObject-0001")
    );
    DataObject item = result.getItem();
    String fileUrl = result.getFileUrl();
    long contentLength = result.getContentLength();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareDownloadByUserIdAndDataObjectNameRequest;
using Gs2.Gs2Datastore.Result.PrepareDownloadByUserIdAndDataObjectNameResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareDownloadByUserIdAndDataObjectNameResult> asyncResult = null;
yield return client.PrepareDownloadByUserIdAndDataObjectName(
    new Gs2.Gs2Datastore.Request.PrepareDownloadByUserIdAndDataObjectNameRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithDataObjectName("dataObject-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var fileUrl = result.FileUrl;
var contentLength = result.ContentLength;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareDownloadByUserIdAndDataObjectName(
        new Gs2Datastore.PrepareDownloadByUserIdAndDataObjectNameRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withDataObjectName("dataObject-0001")
    );
    const item = result.getItem();
    const fileUrl = result.getFileUrl();
    const contentLength = result.getContentLength();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_download_by_user_id_and_data_object_name(
        datastore.PrepareDownloadByUserIdAndDataObjectNameRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_data_object_name('dataObject-0001')
    )
    item = result.item
    file_url = result.file_url
    content_length = result.content_length
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_download_by_user_id_and_data_object_name({
    namespaceName='namespace1',
    userId='user-0001',
    dataObjectName='dataObject-0001',
})

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

result = api_result.result
item = result.item;
fileUrl = result.fileUrl;
contentLength = result.contentLength;

Prepare data object for download by specifying user ID and object name

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name

Result

	Type	Description
item	DataObject	Data object
fileUrl	string	URL to download the file
contentLength	long	File size

prepareDownloadOwnDataByGeneration

prepareDownloadOwnDataByGeneration

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareDownloadOwnDataByGeneration(
    &datastore.PrepareDownloadOwnDataByGenerationRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        DataObjectName: pointy.String("dataObject-0001"),
        Generation: pointy.String("generation-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
fileUrl := result.FileUrl
contentLength := result.ContentLength

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareDownloadOwnDataByGenerationRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareDownloadOwnDataByGeneration(
        (new PrepareDownloadOwnDataByGenerationRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withDataObjectName("dataObject-0001")
            ->withGeneration("generation-0001")
    );
    $item = $result->getItem();
    $fileUrl = $result->getFileUrl();
    $contentLength = $result->getContentLength();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareDownloadOwnDataByGenerationRequest;
import io.gs2.datastore.result.PrepareDownloadOwnDataByGenerationResult;

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

try {
    PrepareDownloadOwnDataByGenerationResult result = client.prepareDownloadOwnDataByGeneration(
        new PrepareDownloadOwnDataByGenerationRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectName("dataObject-0001")
            .withGeneration("generation-0001")
    );
    DataObject item = result.getItem();
    String fileUrl = result.getFileUrl();
    long contentLength = result.getContentLength();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareDownloadOwnDataByGenerationRequest;
using Gs2.Gs2Datastore.Result.PrepareDownloadOwnDataByGenerationResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareDownloadOwnDataByGenerationResult> asyncResult = null;
yield return client.PrepareDownloadOwnDataByGeneration(
    new Gs2.Gs2Datastore.Request.PrepareDownloadOwnDataByGenerationRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001")
        .WithDataObjectName("dataObject-0001")
        .WithGeneration("generation-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var fileUrl = result.FileUrl;
var contentLength = result.ContentLength;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareDownloadOwnDataByGeneration(
        new Gs2Datastore.PrepareDownloadOwnDataByGenerationRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectName("dataObject-0001")
            .withGeneration("generation-0001")
    );
    const item = result.getItem();
    const fileUrl = result.getFileUrl();
    const contentLength = result.getContentLength();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_download_own_data_by_generation(
        datastore.PrepareDownloadOwnDataByGenerationRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_data_object_name('dataObject-0001')
            .with_generation('generation-0001')
    )
    item = result.item
    file_url = result.file_url
    content_length = result.content_length
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_download_own_data_by_generation({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    dataObjectName='dataObject-0001',
    generation='generation-0001',
})

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

result = api_result.result
item = result.item;
fileUrl = result.fileUrl;
contentLength = result.contentLength;

Prepare data objects for download by specifying the generation

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name
generation	string	✓		~ 128 chars	Data Generation

Result

	Type	Description
item	DataObject	Data object
fileUrl	string	URL to download the file
contentLength	long	File size

prepareDownloadByUserIdAndDataObjectNameAndGeneration

prepareDownloadByUserIdAndDataObjectNameAndGeneration

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.PrepareDownloadByUserIdAndDataObjectNameAndGeneration(
    &datastore.PrepareDownloadByUserIdAndDataObjectNameAndGenerationRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        DataObjectName: pointy.String("dataObject-0001"),
        Generation: pointy.String("generation-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
fileUrl := result.FileUrl
contentLength := result.ContentLength

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\PrepareDownloadByUserIdAndDataObjectNameAndGenerationRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareDownloadByUserIdAndDataObjectNameAndGeneration(
        (new PrepareDownloadByUserIdAndDataObjectNameAndGenerationRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withDataObjectName("dataObject-0001")
            ->withGeneration("generation-0001")
    );
    $item = $result->getItem();
    $fileUrl = $result->getFileUrl();
    $contentLength = $result->getContentLength();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.PrepareDownloadByUserIdAndDataObjectNameAndGenerationRequest;
import io.gs2.datastore.result.PrepareDownloadByUserIdAndDataObjectNameAndGenerationResult;

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

try {
    PrepareDownloadByUserIdAndDataObjectNameAndGenerationResult result = client.prepareDownloadByUserIdAndDataObjectNameAndGeneration(
        new PrepareDownloadByUserIdAndDataObjectNameAndGenerationRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withDataObjectName("dataObject-0001")
            .withGeneration("generation-0001")
    );
    DataObject item = result.getItem();
    String fileUrl = result.getFileUrl();
    long contentLength = result.getContentLength();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.PrepareDownloadByUserIdAndDataObjectNameAndGenerationRequest;
using Gs2.Gs2Datastore.Result.PrepareDownloadByUserIdAndDataObjectNameAndGenerationResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.PrepareDownloadByUserIdAndDataObjectNameAndGenerationResult> asyncResult = null;
yield return client.PrepareDownloadByUserIdAndDataObjectNameAndGeneration(
    new Gs2.Gs2Datastore.Request.PrepareDownloadByUserIdAndDataObjectNameAndGenerationRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithDataObjectName("dataObject-0001")
        .WithGeneration("generation-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var fileUrl = result.FileUrl;
var contentLength = result.ContentLength;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.prepareDownloadByUserIdAndDataObjectNameAndGeneration(
        new Gs2Datastore.PrepareDownloadByUserIdAndDataObjectNameAndGenerationRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withDataObjectName("dataObject-0001")
            .withGeneration("generation-0001")
    );
    const item = result.getItem();
    const fileUrl = result.getFileUrl();
    const contentLength = result.getContentLength();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.prepare_download_by_user_id_and_data_object_name_and_generation(
        datastore.PrepareDownloadByUserIdAndDataObjectNameAndGenerationRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_data_object_name('dataObject-0001')
            .with_generation('generation-0001')
    )
    item = result.item
    file_url = result.file_url
    content_length = result.content_length
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.prepare_download_by_user_id_and_data_object_name_and_generation({
    namespaceName='namespace1',
    userId='user-0001',
    dataObjectName='dataObject-0001',
    generation='generation-0001',
})

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

result = api_result.result
item = result.item;
fileUrl = result.fileUrl;
contentLength = result.contentLength;

Prepare data object for download by specifying user ID and generation

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
dataObjectName	string	✓	UUID	~ 128 chars	Data object Name
generation	string	✓		~ 128 chars	Data Generation

Result

	Type	Description
item	DataObject	Data object
fileUrl	string	URL to download the file
contentLength	long	File size

restoreDataObject

restoreDataObject

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.RestoreDataObject(
    &datastore.RestoreDataObjectRequest {
        NamespaceName: pointy.String("namespace1"),
        DataObjectId: pointy.String("grn:dataObject-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\RestoreDataObjectRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->restoreDataObject(
        (new RestoreDataObjectRequest())
            ->withNamespaceName(self::namespace1)
            ->withDataObjectId("grn:dataObject-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.RestoreDataObjectRequest;
import io.gs2.datastore.result.RestoreDataObjectResult;

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

try {
    RestoreDataObjectResult result = client.restoreDataObject(
        new RestoreDataObjectRequest()
            .withNamespaceName("namespace1")
            .withDataObjectId("grn:dataObject-0001")
    );
    DataObject item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.RestoreDataObjectRequest;
using Gs2.Gs2Datastore.Result.RestoreDataObjectResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.RestoreDataObjectResult> asyncResult = null;
yield return client.RestoreDataObject(
    new Gs2.Gs2Datastore.Request.RestoreDataObjectRequest()
        .WithNamespaceName("namespace1")
        .WithDataObjectId("grn:dataObject-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.restoreDataObject(
        new Gs2Datastore.RestoreDataObjectRequest()
            .withNamespaceName("namespace1")
            .withDataObjectId("grn:dataObject-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.restore_data_object(
        datastore.RestoreDataObjectRequest()
            .with_namespace_name(self.hash1)
            .with_data_object_id('grn:dataObject-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.restore_data_object({
    namespaceName='namespace1',
    dataObjectId='grn:dataObject-0001',
})

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

result = api_result.result
item = result.item;

Repair management information on data objects

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
dataObjectId	string	✓		~ 1024 chars	Data object GRN

Result

	Type	Description
item	DataObject	Data object

describeDataObjectHistories

describeDataObjectHistories

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.DescribeDataObjectHistories(
    &datastore.DescribeDataObjectHistoriesRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        DataObjectName: pointy.String("dataObject-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\DescribeDataObjectHistoriesRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeDataObjectHistories(
        (new DescribeDataObjectHistoriesRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withDataObjectName("dataObject-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.DescribeDataObjectHistoriesRequest;
import io.gs2.datastore.result.DescribeDataObjectHistoriesResult;

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

try {
    DescribeDataObjectHistoriesResult result = client.describeDataObjectHistories(
        new DescribeDataObjectHistoriesRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectName("dataObject-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<DataObjectHistory> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.DescribeDataObjectHistoriesRequest;
using Gs2.Gs2Datastore.Result.DescribeDataObjectHistoriesResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.DescribeDataObjectHistoriesResult> asyncResult = null;
yield return client.DescribeDataObjectHistories(
    new Gs2.Gs2Datastore.Request.DescribeDataObjectHistoriesRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001")
        .WithDataObjectName("dataObject-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.describeDataObjectHistories(
        new Gs2Datastore.DescribeDataObjectHistoriesRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectName("dataObject-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.describe_data_object_histories(
        datastore.DescribeDataObjectHistoriesRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_data_object_name('dataObject-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.describe_data_object_histories({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    dataObjectName='dataObject-0001',
    pageToken=nil,
    limit=nil,
})

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

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

Obtain list of data object history

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
dataObjectName	string	✓		~ 128 chars	Data object name
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	DataObjectHistory[]	List of History of Data object
nextPageToken	string	Page token to retrieve the rest of the listing

describeDataObjectHistoriesByUserId

describeDataObjectHistoriesByUserId

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.DescribeDataObjectHistoriesByUserId(
    &datastore.DescribeDataObjectHistoriesByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        DataObjectName: pointy.String("dataObject-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\DescribeDataObjectHistoriesByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeDataObjectHistoriesByUserId(
        (new DescribeDataObjectHistoriesByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withDataObjectName("dataObject-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.DescribeDataObjectHistoriesByUserIdRequest;
import io.gs2.datastore.result.DescribeDataObjectHistoriesByUserIdResult;

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

try {
    DescribeDataObjectHistoriesByUserIdResult result = client.describeDataObjectHistoriesByUserId(
        new DescribeDataObjectHistoriesByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withDataObjectName("dataObject-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<DataObjectHistory> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.DescribeDataObjectHistoriesByUserIdRequest;
using Gs2.Gs2Datastore.Result.DescribeDataObjectHistoriesByUserIdResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.DescribeDataObjectHistoriesByUserIdResult> asyncResult = null;
yield return client.DescribeDataObjectHistoriesByUserId(
    new Gs2.Gs2Datastore.Request.DescribeDataObjectHistoriesByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithDataObjectName("dataObject-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.describeDataObjectHistoriesByUserId(
        new Gs2Datastore.DescribeDataObjectHistoriesByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withDataObjectName("dataObject-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.describe_data_object_histories_by_user_id(
        datastore.DescribeDataObjectHistoriesByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_data_object_name('dataObject-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.describe_data_object_histories_by_user_id({
    namespaceName='namespace2',
    userId='user-0001',
    dataObjectName='dataObject-0001',
    pageToken=nil,
    limit=nil,
})

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

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

Obtain list of data object history by specifying a user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
dataObjectName	string	✓		~ 128 chars	Data object name
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	DataObjectHistory[]	List of History of Data object
nextPageToken	string	Page token to retrieve the rest of the listing

getDataObjectHistory

getDataObjectHistory

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.GetDataObjectHistory(
    &datastore.GetDataObjectHistoryRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        DataObjectName: pointy.String("dataObject-0001"),
        Generation: pointy.String("1"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\GetDataObjectHistoryRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getDataObjectHistory(
        (new GetDataObjectHistoryRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withDataObjectName("dataObject-0001")
            ->withGeneration("1")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.GetDataObjectHistoryRequest;
import io.gs2.datastore.result.GetDataObjectHistoryResult;

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

try {
    GetDataObjectHistoryResult result = client.getDataObjectHistory(
        new GetDataObjectHistoryRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectName("dataObject-0001")
            .withGeneration("1")
    );
    DataObjectHistory item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.GetDataObjectHistoryRequest;
using Gs2.Gs2Datastore.Result.GetDataObjectHistoryResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.GetDataObjectHistoryResult> asyncResult = null;
yield return client.GetDataObjectHistory(
    new Gs2.Gs2Datastore.Request.GetDataObjectHistoryRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001")
        .WithDataObjectName("dataObject-0001")
        .WithGeneration("1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.getDataObjectHistory(
        new Gs2Datastore.GetDataObjectHistoryRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
            .withDataObjectName("dataObject-0001")
            .withGeneration("1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.get_data_object_history(
        datastore.GetDataObjectHistoryRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_data_object_name('dataObject-0001')
            .with_generation('1')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.get_data_object_history({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    dataObjectName='dataObject-0001',
    generation='1',
})

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

result = api_result.result
item = result.item;

Obtain data object history

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 32 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
dataObjectName	string	✓	~ 128 chars	Data object name
generation	string	✓	~ 128 chars	Generations ID

Result

	Type	Description
item	DataObjectHistory	History of Data object

getDataObjectHistoryByUserId

getDataObjectHistoryByUserId

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/datastore"
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 := datastore.Gs2DatastoreRestClient{
    Session: &session,
}
result, err := client.GetDataObjectHistoryByUserId(
    &datastore.GetDataObjectHistoryByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        DataObjectName: pointy.String("dataObject-0001"),
        Generation: pointy.String("generation-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Datastore\Gs2DatastoreRestClient;
use Gs2\Datastore\Request\GetDataObjectHistoryByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getDataObjectHistoryByUserId(
        (new GetDataObjectHistoryByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withDataObjectName("dataObject-0001")
            ->withGeneration("generation-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.datastore.rest.Gs2DatastoreRestClient;
import io.gs2.datastore.request.GetDataObjectHistoryByUserIdRequest;
import io.gs2.datastore.result.GetDataObjectHistoryByUserIdResult;

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

try {
    GetDataObjectHistoryByUserIdResult result = client.getDataObjectHistoryByUserId(
        new GetDataObjectHistoryByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withDataObjectName("dataObject-0001")
            .withGeneration("generation-0001")
    );
    DataObjectHistory item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Datastore.Gs2DatastoreRestClient;
using Gs2.Gs2Datastore.Request.GetDataObjectHistoryByUserIdRequest;
using Gs2.Gs2Datastore.Result.GetDataObjectHistoryByUserIdResult;

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

AsyncResult<Gs2.Gs2Datastore.Result.GetDataObjectHistoryByUserIdResult> asyncResult = null;
yield return client.GetDataObjectHistoryByUserId(
    new Gs2.Gs2Datastore.Request.GetDataObjectHistoryByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithDataObjectName("dataObject-0001")
        .WithGeneration("generation-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Datastore from '@/gs2/datastore';

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

try {
    const result = await client.getDataObjectHistoryByUserId(
        new Gs2Datastore.GetDataObjectHistoryByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withDataObjectName("dataObject-0001")
            .withGeneration("generation-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import datastore

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

try:
    result = client.get_data_object_history_by_user_id(
        datastore.GetDataObjectHistoryByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_data_object_name('dataObject-0001')
            .with_generation('generation-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('datastore')

api_result = client.get_data_object_history_by_user_id({
    namespaceName='namespace2',
    userId='user-0001',
    dataObjectName='dataObject-0001',
    generation='generation-0001',
})

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

result = api_result.result
item = result.item;

Obtain data object history by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 32 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
dataObjectName	string	✓	~ 128 chars	Data object name
generation	string	✓	~ 128 chars	Generations ID

Result

	Type	Description
item	DataObjectHistory	History of Data object