NAV
Japanese | English
go python java php typescript csharp GS2-Script

GS2-News

GS2 SDK Reference

GS2 SDK Reference

Models

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.

Type Description
namespaceId string Namespace GRN
name string Namespace Name
description string description of Namespace
version string Version
logSetting LogSetting Log output settings
createdAt long Datetime of creation
updatedAt long Datetime of last update

News

Type Description
section string Section Name
content string Content Name
title string Article Headline
scheduleEventId string Event GRN
timestamp long Timestamp
frontMatter string Front Matter

SetCookieRequestEntry

Type Description
key string Key value of the cookie you would like us to set to be able to view the article
value string 記事を閲覧できるようにするために設定してほしい Cookie の値

LogSetting

Type Description
loggingNamespaceId string Namespace GRN

GitHubCheckoutSetting

Type Description
apiKeyId string GitHub API key GRN
repositoryName string Repository Name
sourcePath string Source code file path
referenceType enum ['commit_hash', 'branch', 'tag'] Source of code
commitHash string Commit hash
branchName string Branch Name
tagName string Tag Name

Methods

describeNamespaces

describeNamespaces

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;



Request

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

Result

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

createNamespace

createNamespace

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/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;



Request

Type Require Default Limitation Description
name string ✓ ~ 32 chars Namespace Name
description string ~ 1024 chars description of Namespace
logSetting LogSetting Log output settings

Result

Type Description
item Namespace Namespace created

getNamespaceStatus

getNamespaceStatus

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;



Request

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

Result

Type Description
status string

getNamespace

getNamespace

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/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;



Request

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

Result

Type Description
item Namespace Namespace

updateNamespace

updateNamespace

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/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;



Request

Type Require Default Limitation Description
namespaceName string ✓ ~ 32 chars Namespace Name
description string ~ 1024 chars description of Namespace
logSetting LogSetting Log output settings

Result

Type Description
item Namespace Updated namespace

deleteNamespace

deleteNamespace

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;



Request

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

Result

Type Description
item Namespace Deleted namespace

prepareUpdateCurrentNewsMaster

prepareUpdateCurrentNewsMaster

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;

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

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

Result

Type Description
uploadToken string Token used to reflect results after upload
templateUploadUrl string URL used to execute the template upload process

updateCurrentNewsMaster

updateCurrentNewsMaster

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

Update currently available notices



Request

Type Require Default Limitation Description
namespaceName string ✓ ~ 32 chars Namespace Name
uploadToken string ✓ ~ 1024 chars Token received in preparation for upload

Result

Type Description

prepareUpdateCurrentNewsMasterFromGitHub

prepareUpdateCurrentNewsMasterFromGitHub

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;

Update currently available notices



Request

Type Require Default Limitation Description
namespaceName string ✓ ~ 32 chars Namespace Name
checkoutSetting GitHubCheckoutSetting ✓ Setup to check out master data from GitHub

Result

Type Description
uploadToken string Token used to reflect results after upload

describeNews

describeNews

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;

Get list of articles



Request

Type Require Default Limitation Description
namespaceName string ✓ ~ 32 chars Namespace Name
accessToken string ✓ ~ 128 chars User Id

Result

Type Description
items News[] List of Articles
contentHash string Hash value of article data
templateHash string Hash value of template data

describeNewsByUserId

describeNewsByUserId

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;

Obtain list of articles by specifying a user ID



Request

Type Require Default Limitation Description
namespaceName string ✓ ~ 32 chars Namespace Name
userId string ✓ ~ 128 chars User Id

Result

Type Description
items News[] List of Articles
contentHash string Hash value of article data
templateHash string Hash value of template data

wantGrant

wantGrant

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;

Get the information needed to access the article



Request

Type Require Default Limitation Description
namespaceName string ✓ ~ 32 chars Namespace Name
accessToken string ✓ ~ 128 chars User Id

Result

Type Description
items SetCookieRequestEntry[] List of cookies that need to be set in order to access the content
browserUrl string URL to access the content
zipUrl string URL to access content in ZIP format / no cookie setting required to access

wantGrantByUserId

wantGrantByUserId

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;

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



Request

Type Require Default Limitation Description
namespaceName string ✓ ~ 32 chars Namespace Name
userId string ✓ ~ 128 chars User Id

Result

Type Description
items SetCookieRequestEntry[] List of cookies that need to be set in order to access the content
browserUrl string URL to access the content
zipUrl string URL to access content in ZIP format / no cookie setting required to access
go python java php typescript csharp GS2-Script