API Reference of GS2-News SDK

Model

Namespace

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.

TypeConditionRequireDefaultLimitationDescription
namespaceIdstring~ 1024 charsNamespace GRN
namestring~ 32 charsNamespace Name
descriptionstring~ 1024 charsdescription of Namespace
versionstring~ 1024 charsVersion
logSettingLogSettingLog output settings
createdAtlongDatetime of creation
updatedAtlongDatetime of last update
revisionlong0~ 9223372036854775805Revision

Progress

Content generation progress

TypeConditionRequireDefaultLimitationDescription
progressIdstring~ 1024 charsContent generation progress GRN
uploadTokenstring~ 1024 charsUpload token
generatedint~ 1000Number of generated content
patternCountint~ 1000Number of content
createdAtlongDatetime of creation
updatedAtlongDatetime of last update
revisionlong0~ 9223372036854775805Revision

Output

Output of content generation progress

TypeConditionRequireDefaultLimitationDescription
outputIdstring~ 1024 charsOutput of content generation progress GRN
namestringUUID~ 36 charsOutput Name
textstring~ 1048576 charsText
createdAtlongDatetime of creation
revisionlong0~ 9223372036854775805Revision

View

TypeConditionRequireDefaultLimitationDescription
contentsList<Content>~ 1000 itemsList of content to include in the view
removeContentsList<Content>~ 1000 itemsList of content not to be included in the view

Content

TypeConditionRequireDefaultLimitationDescription
sectionstring~ 1024 charsSection
contentstring~ 1024 charsContents Name
frontMatterstring~ 1048576 charsFront Matter

News

TypeConditionRequireDefaultLimitationDescription
sectionstring~ 1024 charsSection Name
contentstring~ 1024 charsContent Name
titlestring~ 1024 charsArticle Headline
scheduleEventIdstring~ 1024 charsEvent GRN
timestamplongTimestamp
frontMatterstring~ 1024 charsFront Matter

SetCookieRequestEntry

TypeConditionRequireDefaultLimitationDescription
keystring~ 128 charsKey value of the cookie you would like us to set to be able to view the article
valuestring~ 1024 chars記事を閲覧できるようにするために設定してほしい Cookie の値

LogSetting

TypeConditionRequireDefaultLimitationDescription
loggingNamespaceIdstring~ 1024 charsNamespace GRN

GitHubCheckoutSetting

TypeConditionRequireDefaultLimitationDescription
apiKeyIdstring~ 1024 charsGitHub API key GRN
repositoryNamestring~ 1024 charsRepository Name
sourcePathstring~ 1024 charsSource code file path
referenceTypeenum [‘commit_hash’, ‘branch’, ’tag’]~ 128 charsSource of code
commitHashstring{referenceType} == “commit_hash”~ 1024 charsCommit hash
branchNamestring{referenceType} == “branch”~ 1024 charsBranch Name
tagNamestring{referenceType} == “tag”~ 1024 charsTag Name

Methods

describeNamespaces

Request

TypeConditionRequireDefaultLimitationDescription
pageTokenstring~ 1024 charsToken specifying the position from which to start acquiring data
limitint301 ~ 1000Number of data acquired

Result

TypeDescription
itemsList<Namespace>List of Namespace
nextPageTokenstringPage token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &news.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\News\Gs2NewsRestClient;
use Gs2\News\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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.DescribeNamespacesRequest;
import io.gs2.news.result.DescribeNamespacesResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2NewsRestClient client = new Gs2NewsRestClient(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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.DescribeNamespacesRequest;
using Gs2.Gs2News.Result.DescribeNamespacesResult;

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

AsyncResult<Gs2.Gs2News.Result.DescribeNamespacesResult> asyncResult = null;
yield return client.DescribeNamespaces(
    new Gs2.Gs2News.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 Gs2News from '@/gs2/news';

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

try {
    const result = await client.describeNamespaces(
        new Gs2News.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 news

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

try:
    result = client.describe_namespaces(
        news.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('news')

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;

createNamespace

Request

TypeConditionRequireDefaultLimitationDescription
namestring~ 32 charsNamespace Name
descriptionstring~ 1024 charsdescription of Namespace
logSettingLogSettingLog output settings

Result

TypeDescription
itemNamespaceNamespace created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &news.CreateNamespaceRequest {
        Name: pointy.String("namespace1"),
        Description: nil,
        LogSetting: &news.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log: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\News\Gs2NewsRestClient;
use Gs2\News\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\News\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:\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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.CreateNamespaceRequest;
import io.gs2.news.result.CreateNamespaceResult;

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

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withLogSetting(new io.gs2.news.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log: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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.CreateNamespaceRequest;
using Gs2.Gs2News.Result.CreateNamespaceResult;

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

AsyncResult<Gs2.Gs2News.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2News.Request.CreateNamespaceRequest()
        .WithName("namespace1")
        .WithDescription(null)
        .WithLogSetting(new Gs2.Gs2News.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log: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 Gs2News from '@/gs2/news';

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

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

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

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

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

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

result = api_result.result
item = result.item;

getNamespaceStatus

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name

Result

TypeDescription
statusstring

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &news.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\News\Gs2NewsRestClient;
use Gs2\News\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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.GetNamespaceStatusRequest;
import io.gs2.news.result.GetNamespaceStatusResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2NewsRestClient client = new Gs2NewsRestClient(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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.GetNamespaceStatusRequest;
using Gs2.Gs2News.Result.GetNamespaceStatusResult;

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

AsyncResult<Gs2.Gs2News.Result.GetNamespaceStatusResult> asyncResult = null;
yield return client.GetNamespaceStatus(
    new Gs2.Gs2News.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 Gs2News from '@/gs2/news';

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

try {
    const result = await client.getNamespaceStatus(
        new Gs2News.GetNamespaceStatusRequest()
            .withNamespaceName("namespace1")
    );
    const status = result.getStatus();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

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

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;

getNamespace

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name

Result

TypeDescription
itemNamespaceNamespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &news.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\News\Gs2NewsRestClient;
use Gs2\News\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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.GetNamespaceRequest;
import io.gs2.news.result.GetNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2NewsRestClient client = new Gs2NewsRestClient(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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.GetNamespaceRequest;
using Gs2.Gs2News.Result.GetNamespaceResult;

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

AsyncResult<Gs2.Gs2News.Result.GetNamespaceResult> asyncResult = null;
yield return client.GetNamespace(
    new Gs2.Gs2News.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 Gs2News from '@/gs2/news';

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

try {
    const result = await client.getNamespace(
        new Gs2News.GetNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

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

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;

updateNamespace

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
descriptionstring~ 1024 charsdescription of Namespace
logSettingLogSettingLog output settings

Result

TypeDescription
itemNamespaceUpdated namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &news.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
        Description: pointy.String("description1"),
        LogSetting: &news.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log: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\News\Gs2NewsRestClient;
use Gs2\News\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\News\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:\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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.UpdateNamespaceRequest;
import io.gs2.news.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withLogSetting(new io.gs2.news.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log: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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.UpdateNamespaceRequest;
using Gs2.Gs2News.Result.UpdateNamespaceResult;

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

AsyncResult<Gs2.Gs2News.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2News.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace1")
        .WithDescription("description1")
        .WithLogSetting(new Gs2.Gs2News.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log: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 Gs2News from '@/gs2/news';

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

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

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

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

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

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

result = api_result.result
item = result.item;

deleteNamespace

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name

Result

TypeDescription
itemNamespaceDeleted namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &news.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\News\Gs2NewsRestClient;
use Gs2\News\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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.DeleteNamespaceRequest;
import io.gs2.news.result.DeleteNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2NewsRestClient client = new Gs2NewsRestClient(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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.DeleteNamespaceRequest;
using Gs2.Gs2News.Result.DeleteNamespaceResult;

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

AsyncResult<Gs2.Gs2News.Result.DeleteNamespaceResult> asyncResult = null;
yield return client.DeleteNamespace(
    new Gs2.Gs2News.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 Gs2News from '@/gs2/news';

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

try {
    const result = await client.deleteNamespace(
        new Gs2News.DeleteNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

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

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;

describeProgresses

Get a list of content generation progress

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
pageTokenstring~ 1024 charsToken specifying the position from which to start acquiring data
limitint301 ~ 1000Number of data acquired

Result

TypeDescription
itemsList<Progress>List of Content generation progress
nextPageTokenstringPage token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.DescribeProgresses(
    &news.DescribeProgressesRequest {
        NamespaceName: pointy.String("namespace1"),
        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\News\Gs2NewsRestClient;
use Gs2\News\Request\DescribeProgressesRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeProgresses(
        (new DescribeProgressesRequest())
            ->withNamespaceName(self::namespace1)
            ->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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.DescribeProgressesRequest;
import io.gs2.news.result.DescribeProgressesResult;

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

try {
    DescribeProgressesResult result = client.describeProgresses(
        new DescribeProgressesRequest()
            .withNamespaceName("namespace1")
            .withPageToken(null)
            .withLimit(null)
    );
    List<Progress> 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.DescribeProgressesRequest;
using Gs2.Gs2News.Result.DescribeProgressesResult;

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

AsyncResult<Gs2.Gs2News.Result.DescribeProgressesResult> asyncResult = null;
yield return client.DescribeProgresses(
    new Gs2.Gs2News.Request.DescribeProgressesRequest()
        .WithNamespaceName("namespace1")
        .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 Gs2News from '@/gs2/news';

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

try {
    const result = await client.describeProgresses(
        new Gs2News.DescribeProgressesRequest()
            .withNamespaceName("namespace1")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

try:
    result = client.describe_progresses(
        news.DescribeProgressesRequest()
            .with_namespace_name(self.hash1)
            .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('news')

api_result = client.describe_progresses({
    namespaceName='namespace1',
    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;

getProgress

Obtain content generation progress

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
uploadTokenstring~ 1024 charsUpload token

Result

TypeDescription
itemProgressProgress

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.GetProgress(
    &news.GetProgressRequest {
        NamespaceName: pointy.String("namespace1"),
        UploadToken: pointy.String("upload-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\News\Gs2NewsRestClient;
use Gs2\News\Request\GetProgressRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getProgress(
        (new GetProgressRequest())
            ->withNamespaceName(self::namespace1)
            ->withUploadToken("upload-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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.GetProgressRequest;
import io.gs2.news.result.GetProgressResult;

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

try {
    GetProgressResult result = client.getProgress(
        new GetProgressRequest()
            .withNamespaceName("namespace1")
            .withUploadToken("upload-0001")
    );
    Progress 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.GetProgressRequest;
using Gs2.Gs2News.Result.GetProgressResult;

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

AsyncResult<Gs2.Gs2News.Result.GetProgressResult> asyncResult = null;
yield return client.GetProgress(
    new Gs2.Gs2News.Request.GetProgressRequest()
        .WithNamespaceName("namespace1")
        .WithUploadToken("upload-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 Gs2News from '@/gs2/news';

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

try {
    const result = await client.getProgress(
        new Gs2News.GetProgressRequest()
            .withNamespaceName("namespace1")
            .withUploadToken("upload-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

try:
    result = client.get_progress(
        news.GetProgressRequest()
            .with_namespace_name(self.hash1)
            .with_upload_token('upload-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('news')

api_result = client.get_progress({
    namespaceName='namespace1',
    uploadToken='upload-0001',
})

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

result = api_result.result
item = result.item;

describeOutputs

Get a list of output of content generation progress

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
uploadTokenstring~ 1024 charsUpload token
pageTokenstring~ 1024 charsToken specifying the position from which to start acquiring data
limitint301 ~ 1000Number of data acquired

Result

TypeDescription
itemsList<Output>List of Output of content generation progress
nextPageTokenstringPage token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.DescribeOutputs(
    &news.DescribeOutputsRequest {
        NamespaceName: pointy.String("namespace1"),
        UploadToken: pointy.String("upload-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\News\Gs2NewsRestClient;
use Gs2\News\Request\DescribeOutputsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeOutputs(
        (new DescribeOutputsRequest())
            ->withNamespaceName(self::namespace1)
            ->withUploadToken("upload-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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.DescribeOutputsRequest;
import io.gs2.news.result.DescribeOutputsResult;

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

try {
    DescribeOutputsResult result = client.describeOutputs(
        new DescribeOutputsRequest()
            .withNamespaceName("namespace1")
            .withUploadToken("upload-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<Output> 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.DescribeOutputsRequest;
using Gs2.Gs2News.Result.DescribeOutputsResult;

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

AsyncResult<Gs2.Gs2News.Result.DescribeOutputsResult> asyncResult = null;
yield return client.DescribeOutputs(
    new Gs2.Gs2News.Request.DescribeOutputsRequest()
        .WithNamespaceName("namespace1")
        .WithUploadToken("upload-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 Gs2News from '@/gs2/news';

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

try {
    const result = await client.describeOutputs(
        new Gs2News.DescribeOutputsRequest()
            .withNamespaceName("namespace1")
            .withUploadToken("upload-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 news

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

try:
    result = client.describe_outputs(
        news.DescribeOutputsRequest()
            .with_namespace_name(self.hash1)
            .with_upload_token('upload-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('news')

api_result = client.describe_outputs({
    namespaceName='namespace1',
    uploadToken='upload-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;

getOutput

Obtain output of content generation progress

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
uploadTokenstring~ 1024 charsUpload token
outputNamestringUUID~ 36 charsOutput Name

Result

TypeDescription
itemOutputOutput

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.GetOutput(
    &news.GetOutputRequest {
        NamespaceName: pointy.String("namespace1"),
        UploadToken: pointy.String("upload-0001"),
        OutputName: pointy.String("output-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\News\Gs2NewsRestClient;
use Gs2\News\Request\GetOutputRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getOutput(
        (new GetOutputRequest())
            ->withNamespaceName(self::namespace1)
            ->withUploadToken("upload-0001")
            ->withOutputName("output-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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.GetOutputRequest;
import io.gs2.news.result.GetOutputResult;

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

try {
    GetOutputResult result = client.getOutput(
        new GetOutputRequest()
            .withNamespaceName("namespace1")
            .withUploadToken("upload-0001")
            .withOutputName("output-0001")
    );
    Output 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.GetOutputRequest;
using Gs2.Gs2News.Result.GetOutputResult;

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

AsyncResult<Gs2.Gs2News.Result.GetOutputResult> asyncResult = null;
yield return client.GetOutput(
    new Gs2.Gs2News.Request.GetOutputRequest()
        .WithNamespaceName("namespace1")
        .WithUploadToken("upload-0001")
        .WithOutputName("output-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 Gs2News from '@/gs2/news';

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

try {
    const result = await client.getOutput(
        new Gs2News.GetOutputRequest()
            .withNamespaceName("namespace1")
            .withUploadToken("upload-0001")
            .withOutputName("output-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

try:
    result = client.get_output(
        news.GetOutputRequest()
            .with_namespace_name(self.hash1)
            .with_upload_token('upload-0001')
            .with_output_name('output-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('news')

api_result = client.get_output({
    namespaceName='namespace1',
    uploadToken='upload-0001',
    outputName='output-0001',
})

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

result = api_result.result
item = result.item;

prepareUpdateCurrentNewsMaster

Prepare updates to currently available notices

Upload a zip file with compressed site data to the URL included in the response, and After the upload is complete, updateCurrentNewsMaster is called to reflect the results.

When uploading a zip file, Content-Type must be application/zip.

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name

Result

TypeDescription
uploadTokenstringToken used to reflect results after upload
templateUploadUrlstringURL used to execute the template upload process

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.PrepareUpdateCurrentNewsMaster(
    &news.PrepareUpdateCurrentNewsMasterRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
uploadToken := result.UploadToken
templateUploadUrl := result.TemplateUploadUrl
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\News\Gs2NewsRestClient;
use Gs2\News\Request\PrepareUpdateCurrentNewsMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareUpdateCurrentNewsMaster(
        (new PrepareUpdateCurrentNewsMasterRequest())
            ->withNamespaceName(self::namespace1)
    );
    $uploadToken = $result->getUploadToken();
    $templateUploadUrl = $result->getTemplateUploadUrl();
} 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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.PrepareUpdateCurrentNewsMasterRequest;
import io.gs2.news.result.PrepareUpdateCurrentNewsMasterResult;

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

try {
    PrepareUpdateCurrentNewsMasterResult result = client.prepareUpdateCurrentNewsMaster(
        new PrepareUpdateCurrentNewsMasterRequest()
            .withNamespaceName("namespace1")
    );
    String uploadToken = result.getUploadToken();
    String templateUploadUrl = result.getTemplateUploadUrl();
} 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.PrepareUpdateCurrentNewsMasterRequest;
using Gs2.Gs2News.Result.PrepareUpdateCurrentNewsMasterResult;

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

AsyncResult<Gs2.Gs2News.Result.PrepareUpdateCurrentNewsMasterResult> asyncResult = null;
yield return client.PrepareUpdateCurrentNewsMaster(
    new Gs2.Gs2News.Request.PrepareUpdateCurrentNewsMasterRequest()
        .WithNamespaceName("namespace1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var templateUploadUrl = result.TemplateUploadUrl;
import Gs2Core from '@/gs2/core';
import * as Gs2News from '@/gs2/news';

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

try {
    const result = await client.prepareUpdateCurrentNewsMaster(
        new Gs2News.PrepareUpdateCurrentNewsMasterRequest()
            .withNamespaceName("namespace1")
    );
    const uploadToken = result.getUploadToken();
    const templateUploadUrl = result.getTemplateUploadUrl();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

try:
    result = client.prepare_update_current_news_master(
        news.PrepareUpdateCurrentNewsMasterRequest()
            .with_namespace_name(self.hash1)
    )
    upload_token = result.upload_token
    template_upload_url = result.template_upload_url
except core.Gs2Exception as e:
    exit(1)
client = gs2('news')

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

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

result = api_result.result
uploadToken = result.uploadToken;
templateUploadUrl = result.templateUploadUrl;

updateCurrentNewsMaster

Update currently available notices

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
uploadTokenstring~ 1024 charsToken received in preparation for upload

Result

TypeDescription

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentNewsMaster(
    &news.UpdateCurrentNewsMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        UploadToken: pointy.String("token"),
    }
)
if err != nil {
    panic("error occurred")
}
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\News\Gs2NewsRestClient;
use Gs2\News\Request\UpdateCurrentNewsMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateCurrentNewsMaster(
        (new UpdateCurrentNewsMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withUploadToken("token")
    );
} 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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.UpdateCurrentNewsMasterRequest;
import io.gs2.news.result.UpdateCurrentNewsMasterResult;

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

try {
    UpdateCurrentNewsMasterResult result = client.updateCurrentNewsMaster(
        new UpdateCurrentNewsMasterRequest()
            .withNamespaceName("namespace1")
            .withUploadToken("token")
    );
} 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.UpdateCurrentNewsMasterRequest;
using Gs2.Gs2News.Result.UpdateCurrentNewsMasterResult;

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

AsyncResult<Gs2.Gs2News.Result.UpdateCurrentNewsMasterResult> asyncResult = null;
yield return client.UpdateCurrentNewsMaster(
    new Gs2.Gs2News.Request.UpdateCurrentNewsMasterRequest()
        .WithNamespaceName("namespace1")
        .WithUploadToken("token"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
import Gs2Core from '@/gs2/core';
import * as Gs2News from '@/gs2/news';

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

try {
    const result = await client.updateCurrentNewsMaster(
        new Gs2News.UpdateCurrentNewsMasterRequest()
            .withNamespaceName("namespace1")
            .withUploadToken("token")
    );
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

try:
    result = client.update_current_news_master(
        news.UpdateCurrentNewsMasterRequest()
            .with_namespace_name(self.hash1)
            .with_upload_token('token')
    )
except core.Gs2Exception as e:
    exit(1)
client = gs2('news')

api_result = client.update_current_news_master({
    namespaceName='namespace1',
    uploadToken='token',
})

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

result = api_result.result

prepareUpdateCurrentNewsMasterFromGitHub

Update currently available notices

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
checkoutSettingGitHubCheckoutSettingSetup to check out master data from GitHub

Result

TypeDescription
uploadTokenstringToken used to reflect results after upload

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.PrepareUpdateCurrentNewsMasterFromGitHub(
    &news.PrepareUpdateCurrentNewsMasterFromGitHubRequest {
        NamespaceName: pointy.String("namespace1"),
        CheckoutSetting: {'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'},
    }
)
if err != nil {
    panic("error occurred")
}
uploadToken := result.UploadToken
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\News\Gs2NewsRestClient;
use Gs2\News\Request\PrepareUpdateCurrentNewsMasterFromGitHubRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareUpdateCurrentNewsMasterFromGitHub(
        (new PrepareUpdateCurrentNewsMasterFromGitHubRequest())
            ->withNamespaceName(self::namespace1)
            ->withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    );
    $uploadToken = $result->getUploadToken();
} 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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.PrepareUpdateCurrentNewsMasterFromGitHubRequest;
import io.gs2.news.result.PrepareUpdateCurrentNewsMasterFromGitHubResult;

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

try {
    PrepareUpdateCurrentNewsMasterFromGitHubResult result = client.prepareUpdateCurrentNewsMasterFromGitHub(
        new PrepareUpdateCurrentNewsMasterFromGitHubRequest()
            .withNamespaceName("namespace1")
            .withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    );
    String uploadToken = result.getUploadToken();
} 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.PrepareUpdateCurrentNewsMasterFromGitHubRequest;
using Gs2.Gs2News.Result.PrepareUpdateCurrentNewsMasterFromGitHubResult;

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

AsyncResult<Gs2.Gs2News.Result.PrepareUpdateCurrentNewsMasterFromGitHubResult> asyncResult = null;
yield return client.PrepareUpdateCurrentNewsMasterFromGitHub(
    new Gs2.Gs2News.Request.PrepareUpdateCurrentNewsMasterFromGitHubRequest()
        .WithNamespaceName("namespace1")
        .WithCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'}),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
import Gs2Core from '@/gs2/core';
import * as Gs2News from '@/gs2/news';

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

try {
    const result = await client.prepareUpdateCurrentNewsMasterFromGitHub(
        new Gs2News.PrepareUpdateCurrentNewsMasterFromGitHubRequest()
            .withNamespaceName("namespace1")
            .withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    );
    const uploadToken = result.getUploadToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

try:
    result = client.prepare_update_current_news_master_from_git_hub(
        news.PrepareUpdateCurrentNewsMasterFromGitHubRequest()
            .with_namespace_name(self.hash1)
            .with_checkout_setting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    )
    upload_token = result.upload_token
except core.Gs2Exception as e:
    exit(1)
client = gs2('news')

api_result = client.prepare_update_current_news_master_from_git_hub({
    namespaceName='namespace1',
    checkoutSetting={'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'},
})

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

result = api_result.result
uploadToken = result.uploadToken;

describeNews

Get list of articles

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
accessTokenstring~ 128 charsUser Id

Result

TypeDescription
itemsList<News>List of Articles
contentHashstringHash value of article data
templateHashstringHash value of template data

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.DescribeNews(
    &news.DescribeNewsRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
contentHash := result.ContentHash
templateHash := result.TemplateHash
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\News\Gs2NewsRestClient;
use Gs2\News\Request\DescribeNewsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeNews(
        (new DescribeNewsRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
    );
    $items = $result->getItems();
    $contentHash = $result->getContentHash();
    $templateHash = $result->getTemplateHash();
} 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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.DescribeNewsRequest;
import io.gs2.news.result.DescribeNewsResult;

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

try {
    DescribeNewsResult result = client.describeNews(
        new DescribeNewsRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
    );
    List<News> items = result.getItems();
    String contentHash = result.getContentHash();
    String templateHash = result.getTemplateHash();
} 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.DescribeNewsRequest;
using Gs2.Gs2News.Result.DescribeNewsResult;

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

AsyncResult<Gs2.Gs2News.Result.DescribeNewsResult> asyncResult = null;
yield return client.DescribeNews(
    new Gs2.Gs2News.Request.DescribeNewsRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var contentHash = result.ContentHash;
var templateHash = result.TemplateHash;
import Gs2Core from '@/gs2/core';
import * as Gs2News from '@/gs2/news';

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

try {
    const result = await client.describeNews(
        new Gs2News.DescribeNewsRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
    );
    const items = result.getItems();
    const contentHash = result.getContentHash();
    const templateHash = result.getTemplateHash();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

try:
    result = client.describe_news(
        news.DescribeNewsRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
    )
    items = result.items
    content_hash = result.content_hash
    template_hash = result.template_hash
except core.Gs2Exception as e:
    exit(1)
client = gs2('news')

api_result = client.describe_news({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
})

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

result = api_result.result
items = result.items;
contentHash = result.contentHash;
templateHash = result.templateHash;

describeNewsByUserId

Obtain list of articles by specifying a user ID

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
userIdstring~ 128 charsUser Id

Result

TypeDescription
itemsList<News>List of Articles
contentHashstringHash value of article data
templateHashstringHash value of template data

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.DescribeNewsByUserId(
    &news.DescribeNewsByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
contentHash := result.ContentHash
templateHash := result.TemplateHash
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\News\Gs2NewsRestClient;
use Gs2\News\Request\DescribeNewsByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeNewsByUserId(
        (new DescribeNewsByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
    );
    $items = $result->getItems();
    $contentHash = $result->getContentHash();
    $templateHash = $result->getTemplateHash();
} 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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.DescribeNewsByUserIdRequest;
import io.gs2.news.result.DescribeNewsByUserIdResult;

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

try {
    DescribeNewsByUserIdResult result = client.describeNewsByUserId(
        new DescribeNewsByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
    );
    List<News> items = result.getItems();
    String contentHash = result.getContentHash();
    String templateHash = result.getTemplateHash();
} 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.DescribeNewsByUserIdRequest;
using Gs2.Gs2News.Result.DescribeNewsByUserIdResult;

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

AsyncResult<Gs2.Gs2News.Result.DescribeNewsByUserIdResult> asyncResult = null;
yield return client.DescribeNewsByUserId(
    new Gs2.Gs2News.Request.DescribeNewsByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var contentHash = result.ContentHash;
var templateHash = result.TemplateHash;
import Gs2Core from '@/gs2/core';
import * as Gs2News from '@/gs2/news';

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

try {
    const result = await client.describeNewsByUserId(
        new Gs2News.DescribeNewsByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
    );
    const items = result.getItems();
    const contentHash = result.getContentHash();
    const templateHash = result.getTemplateHash();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

try:
    result = client.describe_news_by_user_id(
        news.DescribeNewsByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
    )
    items = result.items
    content_hash = result.content_hash
    template_hash = result.template_hash
except core.Gs2Exception as e:
    exit(1)
client = gs2('news')

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

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

result = api_result.result
items = result.items;
contentHash = result.contentHash;
templateHash = result.templateHash;

wantGrant

Get the information needed to access the article

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
accessTokenstring~ 128 charsUser Id

Result

TypeDescription
itemsList<SetCookieRequestEntry>List of cookies that need to be set in order to access the content
browserUrlstringURL to access the content
zipUrlstringURL to access content in ZIP format / no cookie setting required to access

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.WantGrant(
    &news.WantGrantRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
browserUrl := result.BrowserUrl
zipUrl := result.ZipUrl
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\News\Gs2NewsRestClient;
use Gs2\News\Request\WantGrantRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->wantGrant(
        (new WantGrantRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
    );
    $items = $result->getItems();
    $browserUrl = $result->getBrowserUrl();
    $zipUrl = $result->getZipUrl();
} 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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.WantGrantRequest;
import io.gs2.news.result.WantGrantResult;

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

try {
    WantGrantResult result = client.wantGrant(
        new WantGrantRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
    );
    List<SetCookieRequestEntry> items = result.getItems();
    String browserUrl = result.getBrowserUrl();
    String zipUrl = result.getZipUrl();
} 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.WantGrantRequest;
using Gs2.Gs2News.Result.WantGrantResult;

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

AsyncResult<Gs2.Gs2News.Result.WantGrantResult> asyncResult = null;
yield return client.WantGrant(
    new Gs2.Gs2News.Request.WantGrantRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var browserUrl = result.BrowserUrl;
var zipUrl = result.ZipUrl;
import Gs2Core from '@/gs2/core';
import * as Gs2News from '@/gs2/news';

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

try {
    const result = await client.wantGrant(
        new Gs2News.WantGrantRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("$access_token_0001")
    );
    const items = result.getItems();
    const browserUrl = result.getBrowserUrl();
    const zipUrl = result.getZipUrl();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

try:
    result = client.want_grant(
        news.WantGrantRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
    )
    items = result.items
    browser_url = result.browser_url
    zip_url = result.zip_url
except core.Gs2Exception as e:
    exit(1)
client = gs2('news')

api_result = client.want_grant({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
})

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

result = api_result.result
items = result.items;
browserUrl = result.browserUrl;
zipUrl = result.zipUrl;

wantGrantByUserId

Obtain the information necessary to access an article by specifying a user ID

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace Name
userIdstring~ 128 charsUser Id

Result

TypeDescription
itemsList<SetCookieRequestEntry>List of cookies that need to be set in order to access the content
browserUrlstringURL to access the content
zipUrlstringURL to access content in ZIP format / no cookie setting required to access

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/news"
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 := news.Gs2NewsRestClient{
    Session: &session,
}
result, err := client.WantGrantByUserId(
    &news.WantGrantByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
browserUrl := result.BrowserUrl
zipUrl := result.ZipUrl
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\News\Gs2NewsRestClient;
use Gs2\News\Request\WantGrantByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->wantGrantByUserId(
        (new WantGrantByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
    );
    $items = $result->getItems();
    $browserUrl = $result->getBrowserUrl();
    $zipUrl = $result->getZipUrl();
} 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.news.rest.Gs2NewsRestClient;
import io.gs2.news.request.WantGrantByUserIdRequest;
import io.gs2.news.result.WantGrantByUserIdResult;

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

try {
    WantGrantByUserIdResult result = client.wantGrantByUserId(
        new WantGrantByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
    );
    List<SetCookieRequestEntry> items = result.getItems();
    String browserUrl = result.getBrowserUrl();
    String zipUrl = result.getZipUrl();
} 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.Gs2News.Gs2NewsRestClient;
using Gs2.Gs2News.Request.WantGrantByUserIdRequest;
using Gs2.Gs2News.Result.WantGrantByUserIdResult;

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

AsyncResult<Gs2.Gs2News.Result.WantGrantByUserIdResult> asyncResult = null;
yield return client.WantGrantByUserId(
    new Gs2.Gs2News.Request.WantGrantByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var browserUrl = result.BrowserUrl;
var zipUrl = result.ZipUrl;
import Gs2Core from '@/gs2/core';
import * as Gs2News from '@/gs2/news';

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

try {
    const result = await client.wantGrantByUserId(
        new Gs2News.WantGrantByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
    );
    const items = result.getItems();
    const browserUrl = result.getBrowserUrl();
    const zipUrl = result.getZipUrl();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import news

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

try:
    result = client.want_grant_by_user_id(
        news.WantGrantByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
    )
    items = result.items
    browser_url = result.browser_url
    zip_url = result.zip_url
except core.Gs2Exception as e:
    exit(1)
client = gs2('news')

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

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

result = api_result.result
items = result.items;
browserUrl = result.browserUrl;
zipUrl = result.zipUrl;