Ask or search…
⌃K
Comment on page
📠

Schema

Get object schema list

GET /jsm/assets/workspace/{workspaceId}/v1/objectschema/list
The List method return all the object schemas available on Assets.
package main
​
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/assets"
"github.com/ctreminiom/go-atlassian/jira/sm"
"log"
"os"
)
​
func main() {
​
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
​
serviceManagement, err := sm.New(nil, host)
if err != nil {
log.Fatal(err)
}
​
serviceManagement.Auth.SetBasicAuth(mail, token)
serviceManagement.Auth.SetUserAgent("curl/7.54.0")
​
// Get the workspace ID
workspaces, response, err := serviceManagement.WorkSpace.Gets(context.Background())
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
workSpaceID := workspaces.Values[0].WorkspaceId
​
// Instance the Assets Cloud client
asset, err := assets.New(nil)
if err != nil {
log.Fatal(err)
}
​
asset.Auth.SetBasicAuth(mail, token)
​
schemas, response, err := asset.ObjectSchema.List(context.Background(), workSpaceID)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
for _, schema := range schemas.Values {
​
fmt.Println("--------")
fmt.Println(schema.Name)
fmt.Println(schema.GlobalId)
fmt.Println(schema.Id)
fmt.Println(schema.Name)
fmt.Println(schema.ObjectSchemaKey)
fmt.Println(schema.Status)
fmt.Println(schema.Description)
fmt.Println(schema.Created)
fmt.Println(schema.Updated)
fmt.Println(schema.ObjectCount)
fmt.Println(schema.ObjectTypeCount)
fmt.Println(schema.CanManage)
fmt.Println("--------")
}
}

Create object schema

POST /jsm/assets/workspace/{workspaceId}/v1/objectschema/create
The Create method creates a new object schema
package main
​
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/assets"
"github.com/ctreminiom/go-atlassian/jira/sm"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"log"
"os"
)
​
func main() {
​
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
​
serviceManagement, err := sm.New(nil, host)
if err != nil {
log.Fatal(err)
}
​
serviceManagement.Auth.SetBasicAuth(mail, token)
serviceManagement.Auth.SetUserAgent("curl/7.54.0")
​
// Get the workspace ID
workspaces, response, err := serviceManagement.WorkSpace.Gets(context.Background())
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
workSpaceID := workspaces.Values[0].WorkspaceId
​
// Instance the Assets Cloud client
asset, err := assets.New(nil)
if err != nil {
log.Fatal(err)
}
​
asset.Auth.SetBasicAuth(mail, token)
​
payload := &models.ObjectSchemaPayloadScheme{
Name: "Computers",
ObjectSchemaKey: "COMP",
Description: "The IT department schema",
}
​
schema, response, err := asset.ObjectSchema.Create(context.Background(), workSpaceID, payload)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
fmt.Println("--------")
fmt.Println(schema.Name)
fmt.Println(schema.GlobalId)
fmt.Println(schema.Id)
fmt.Println(schema.Name)
fmt.Println(schema.ObjectSchemaKey)
fmt.Println(schema.Status)
fmt.Println(schema.Description)
fmt.Println(schema.Created)
fmt.Println(schema.Updated)
fmt.Println(schema.ObjectCount)
fmt.Println(schema.ObjectTypeCount)
fmt.Println(schema.CanManage)
fmt.Println("--------")
}

Get object schema

GET /jsm/assets/workspace/{workspaceId}/v1/objectschema/{id}
The Get method returns an object schema by ID
package main
​
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/assets"
"github.com/ctreminiom/go-atlassian/jira/sm"
"log"
"os"
)
​
func main() {
​
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
​
serviceManagement, err := sm.New(nil, host)
if err != nil {
log.Fatal(err)
}
​
serviceManagement.Auth.SetBasicAuth(mail, token)
serviceManagement.Auth.SetUserAgent("curl/7.54.0")
​
// Get the workspace ID
workspaces, response, err := serviceManagement.WorkSpace.Gets(context.Background())
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
workSpaceID := workspaces.Values[0].WorkspaceId
​
// Instance the Assets Cloud client
asset, err := assets.New(nil)
if err != nil {
log.Fatal(err)
}
​
asset.Auth.SetBasicAuth(mail, token)
​
schema, response, err := asset.ObjectSchema.Get(context.Background(), workSpaceID, "3")
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
fmt.Println("--------")
fmt.Println(schema.Name)
fmt.Println(schema.GlobalId)
fmt.Println(schema.Id)
fmt.Println(schema.Name)
fmt.Println(schema.ObjectSchemaKey)
fmt.Println(schema.Status)
fmt.Println(schema.Description)
fmt.Println(schema.Created)
fmt.Println(schema.Updated)
fmt.Println(schema.ObjectCount)
fmt.Println(schema.ObjectTypeCount)
fmt.Println(schema.CanManage)
fmt.Println("--------")
}

Update object schema

PUT /jsm/assets/workspace/{workspaceId}/v1/objectschema/{id}
The Update method updates an object schema
package main
​
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/assets"
"github.com/ctreminiom/go-atlassian/jira/sm"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"log"
"os"
)
​
func main() {
​
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
​
serviceManagement, err := sm.New(nil, host)
if err != nil {
log.Fatal(err)
}
​
serviceManagement.Auth.SetBasicAuth(mail, token)
serviceManagement.Auth.SetUserAgent("curl/7.54.0")
​
// Get the workspace ID
workspaces, response, err := serviceManagement.WorkSpace.Gets(context.Background())
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
workSpaceID := workspaces.Values[0].WorkspaceId
​
// Instance the Assets Cloud client
asset, err := assets.New(nil)
if err != nil {
log.Fatal(err)
}
​
asset.Auth.SetBasicAuth(mail, token)
​
payload := &models.ObjectSchemaPayloadScheme{
Name: "Computers - UPDATED",
ObjectSchemaKey: "COMPDE",
Description: "The IT department schema - UPDATED",
}
​
schema, response, err := asset.ObjectSchema.Update(context.Background(), workSpaceID, "3", payload)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
fmt.Println("--------")
fmt.Println(schema.Name)
fmt.Println(schema.GlobalId)
fmt.Println(schema.Id)
fmt.Println(schema.Name)
fmt.Println(schema.ObjectSchemaKey)
fmt.Println(schema.Status)
fmt.Println(schema.Description)
fmt.Println(schema.Created)
fmt.Println(schema.Updated)
fmt.Println(schema.ObjectCount)
fmt.Println(schema.ObjectTypeCount)
fmt.Println(schema.CanManage)
fmt.Println("--------")
}

Delete object schema

DELETE /jsm/assets/workspace/{workspaceId}/v1/objectschema/{id}
The Delete method deletes a schema
package main
​
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/assets"
"github.com/ctreminiom/go-atlassian/jira/sm"
"log"
"os"
)
​
func main() {
​
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
​
serviceManagement, err := sm.New(nil, host)
if err != nil {
log.Fatal(err)
}
​
serviceManagement.Auth.SetBasicAuth(mail, token)
serviceManagement.Auth.SetUserAgent("curl/7.54.0")
​
// Get the workspace ID
workspaces, response, err := serviceManagement.WorkSpace.Gets(context.Background())
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
workSpaceID := workspaces.Values[0].WorkspaceId
​
// Instance the Assets Cloud client
asset, err := assets.New(nil)
if err != nil {
log.Fatal(err)
}
​
asset.Auth.SetBasicAuth(mail, token)
​
schema, response, err := asset.ObjectSchema.Delete(context.Background(), workSpaceID, "3")
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
fmt.Println("--------")
fmt.Println(schema.Name)
fmt.Println(schema.GlobalId)
fmt.Println(schema.Id)
fmt.Println(schema.Name)
fmt.Println(schema.ObjectSchemaKey)
fmt.Println(schema.Status)
fmt.Println(schema.Description)
fmt.Println(schema.Created)
fmt.Println(schema.Updated)
fmt.Println(schema.ObjectCount)
fmt.Println(schema.ObjectTypeCount)
fmt.Println(schema.CanManage)
fmt.Println("--------")
}

Get object schema attributes

GET /jsm/assets/workspace/{workspaceId}/v1/objectschema/{id}/attributes
The Attributes method finds all the object type attributes for this object schema
package main
​
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/assets"
"github.com/ctreminiom/go-atlassian/jira/sm"
"github.com/ctreminiom/go-atlassian/pkg/infra/models"
"log"
"os"
)
​
func main() {
​
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
​
serviceManagement, err := sm.New(nil, host)
if err != nil {
log.Fatal(err)
}
​
serviceManagement.Auth.SetBasicAuth(mail, token)
serviceManagement.Auth.SetUserAgent("curl/7.54.0")
​
// Get the workspace ID
workspaces, response, err := serviceManagement.WorkSpace.Gets(context.Background())
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
workSpaceID := workspaces.Values[0].WorkspaceId
​
// Instance the Assets Cloud client
asset, err := assets.New(nil)
if err != nil {
log.Fatal(err)
}
​
asset.Auth.SetBasicAuth(mail, token)
​
options := &models.ObjectSchemaAttributesParamsScheme{
OnlyValueEditable: true,
Extended: true,
Query: "",
}
​
attributes, response, err := asset.ObjectSchema.Attributes(context.Background(), workSpaceID, "1", options)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
for _, attribute := range attributes {
​
fmt.Println("-----")
fmt.Println(attribute.Id)
fmt.Println(attribute.GlobalId)
fmt.Println(attribute.Name)
fmt.Println(attribute.DefaultType)
fmt.Println(attribute.Options)
fmt.Println(attribute.Position)
fmt.Println("-----")
​
}
}

Get object schema types

GET /jsm/assets/workspace/{workspaceId}/v1/objectschema/{id}/objecttypes
The ObjectTypes method returns all the object types for this object schema
package main
​
import (
"context"
"fmt"
"github.com/ctreminiom/go-atlassian/assets"
"github.com/ctreminiom/go-atlassian/jira/sm"
"log"
"os"
)
​
func main() {
​
var (
host = os.Getenv("HOST")
mail = os.Getenv("MAIL")
token = os.Getenv("TOKEN")
)
​
serviceManagement, err := sm.New(nil, host)
if err != nil {
log.Fatal(err)
}
​
serviceManagement.Auth.SetBasicAuth(mail, token)
serviceManagement.Auth.SetUserAgent("curl/7.54.0")
​
// Get the workspace ID
workspaces, response, err := serviceManagement.WorkSpace.Gets(context.Background())
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
workSpaceID := workspaces.Values[0].WorkspaceId
​
// Instance the Assets Cloud client
asset, err := assets.New(nil)
if err != nil {
log.Fatal(err)
}
​
asset.Auth.SetBasicAuth(mail, token)
​
types, response, err := asset.ObjectSchema.ObjectTypes(context.Background(), workSpaceID, "1", false)
if err != nil {
if response != nil {
log.Println(response.Bytes.String())
log.Println("Endpoint:", response.Endpoint)
}
log.Fatal(err)
}
​
for _, objectType := range types {
fmt.Println(objectType)
}
}
Jira Assets - Previous
Object
Next
Type
Last modified 4mo ago