Manage objects

1
// Example code for getting object metadata
2
package main
3
4
import (
5
	"context"
6
	"fmt"
7
	"os"
8
9
	Lattice "github.com/anduril/lattice-sdk-go/v4"
10
	"github.com/anduril/lattice-sdk-go/v4/client"
11
	"github.com/anduril/lattice-sdk-go/v4/option"
12
)
13
14
func main() {
15
	// Get environment variables
16
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
17
	clientSecret := os.Getenv("LATTICE_CLIENT_SECRET")
18
	clientId := os.Getenv("LATTICE_CLIENT_ID")
19
20
	// Remove sandboxesToken from the following statements if you are not developing on Sandboxes
21
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
22
23
	// Check required environment variables
24
	if latticeEndpoint == "" || clientId == "" || clientSecret == "" || sandboxesToken == "" {
25
		fmt.Println("Missing required environment variables")
26
		os.Exit(1)
27
	}
28
29
	// Initialize headers for sandbox authorization
30
	headers := make(map[string][]string)
31
	headers["Anduril-Sandbox-Authorization"] = []string{fmt.Sprintf("Bearer %s", sandboxesToken)}
32
33
	// Create the client
34
	c := client.NewClient(
35
		option.WithClientCredentials(clientId, clientSecret),
36
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
37
		option.WithHTTPHeader(headers),
38
	)
39
	// Set object path
40
	objectPath := "<OBJECT_PATH>"
41
42
	// Create context for the request
43
	ctx := context.Background()
44
45
	// Get the object metadata using HEAD request
46
	response, err := c.Objects.WithRawResponse.GetObjectMetadata(ctx, &Lattice.GetObjectMetadataRequest{ObjectPath: objectPath})
47
	if err != nil {
48
		fmt.Printf("Error getting object metadata: %v\n", err)
49
		os.Exit(1)
50
	}
51
52
	// The response contains headers with metadata information
53
	fmt.Println("Object Metadata:")
54
	fmt.Printf("Status Code: %d\n", response.StatusCode)
55
	fmt.Printf("Path: %s\n", response.Header.Get("Path"))
56
	fmt.Printf("Content-Length: %s bytes\n", response.Header.Get("Content-Length"))
57
	fmt.Printf("Checksum: %s\n", response.Header.Get("Checksum"))
58
	fmt.Printf("Last-Modified: %s\n", response.Header.Get("Last-Modified"))
59
	fmt.Printf("Expires: %s\n", response.Header.Get("Expires"))
60
	fmt.Println("Object metadata retrieved successfully")
61
}

1
package main
2
3
import (
4
	"bytes"
5
	"context"
6
	"fmt"
7
	"net/http"
8
	"os"
9
	"path/filepath"
10
	"strconv"
11
12
	Lattice "github.com/anduril/lattice-sdk-go/v4"
13
	"github.com/anduril/lattice-sdk-go/v4/client"
14
	"github.com/anduril/lattice-sdk-go/v4/option"
15
)
16
17
func main() {
18
	// Get environment variables
19
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
20
	clientSecret := os.Getenv("LATTICE_CLIENT_SECRET")
21
	clientId := os.Getenv("LATTICE_CLIENT_ID")
22
23
	// Remove sandboxesToken from the following statements if you are not developing on Sandboxes
24
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
25
26
	// Check required environment variables
27
	if latticeEndpoint == "" || clientId == "" || clientSecret == "" || sandboxesToken == "" {
28
		fmt.Println("Missing required environment variables")
29
		os.Exit(1)
30
	}
31
32
	// Initialize headers for sandbox authorization
33
	headers := http.Header{}
34
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
35
36
	// Create the client
37
	c := client.NewClient(
38
		option.WithClientCredentials(clientId, clientSecret),
39
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
40
		option.WithHTTPHeader(headers),
41
	)
42
43
	// File path of the object to upload
44
	filePath := "<FILE_PATH_TTL>"
45
46
	// Set TTL to 1 hour in nanoseconds
47
	ttlInNanoseconds := int64(1 * 60 * 60 * 1000000000) // 1 hour in nanoseconds
48
49
	// Create context for the request
50
	ctx := context.Background()
51
52
	// Read the file contents into a byte slice.
53
	fileContent, err := os.ReadFile(filePath)
54
	if err != nil {
55
		fmt.Printf("Error reading file: %v\n", err)
56
		os.Exit(1)
57
	}
58
59
	// Get file name for object path
60
	objectPath := filepath.Base(filePath)
61
62
	// Create TTL header
63
	ttlHeaders := http.Header{}
64
	ttlHeaders.Add("Time-To-Live", strconv.FormatInt(ttlInNanoseconds, 10))
65
66
	// Upload object with TTL header
67
	response, err := c.Objects.UploadObject(
68
		ctx,
69
		objectPath,
70
		bytes.NewReader(fileContent),
71
		option.WithHTTPHeader(ttlHeaders),
72
	)
73
	if err != nil {
74
		fmt.Printf("Error uploading object: %v\n", err)
75
		os.Exit(1)
76
	}
77
78
	fmt.Printf("Object uploaded successfully. Object path: %s\n", response.ContentIdentifier.Path)
79
	fmt.Printf("Object will expire after %d seconds\n", ttlInNanoseconds/1000000000)
80
81
	// Verify the expiry time by getting object metadata
82
	metadataResponse, err := c.Objects.WithRawResponse.GetObjectMetadata(ctx, &Lattice.GetObjectMetadataRequest{ObjectPath: objectPath})
83
	if err != nil {
84
		fmt.Printf("Error getting object metadata: %v\n", err)
85
		os.Exit(1)
86
	}
87
88
	fmt.Printf("Expiry time confirmed: %s\n", metadataResponse.Header.Get("Expires"))
89
}

1
// Example code for deleting an object
2
package main
3
4
import (
5
	"context"
6
	"fmt"
7
	"os"
8
9
	Lattice "github.com/anduril/lattice-sdk-go/v4"
10
	"github.com/anduril/lattice-sdk-go/v4/client"
11
	"github.com/anduril/lattice-sdk-go/v4/option"
12
)
13
14
func main() {
15
	// Get environment variables
16
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
17
	clientSecret := os.Getenv("LATTICE_CLIENT_SECRET")
18
	clientId := os.Getenv("LATTICE_CLIENT_ID")
19
20
	// Remove sandboxesToken from the following statements if you are not developing on Sandboxes
21
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
22
23
	// Check required environment variables
24
	if latticeEndpoint == "" || clientId == "" || clientSecret == "" || sandboxesToken == "" {
25
		fmt.Println("Missing required environment variables")
26
		os.Exit(1)
27
	}
28
29
	// Initialize headers for sandbox authorization
30
	headers := make(map[string][]string)
31
	headers["Anduril-Sandbox-Authorization"] = []string{fmt.Sprintf("Bearer %s", sandboxesToken)}
32
33
	// Create the client
34
	c := client.NewClient(
35
		option.WithClientCredentials(clientId, clientSecret),
36
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
37
		option.WithHTTPHeader(headers),
38
	)
39
	// Set object path to delete
40
	objectPath := "<DELETE_OBJECT_PATH>"
41
42
	// Create context for the request
43
	ctx := context.Background()
44
45
	// Delete the object
46
	err := c.Objects.DeleteObject(ctx, &Lattice.DeleteObjectRequest{ObjectPath: objectPath})
47
	if err != nil {
48
		fmt.Printf("Error deleting object: %v\n", err)
49
		os.Exit(1)
50
	}
51
52
	fmt.Printf("Object deleted successfully: %s\n", objectPath)
53
54
	// Try to access the object to verify it's deleted
55
	_, err = c.Objects.WithRawResponse.GetObjectMetadata(ctx, &Lattice.GetObjectMetadataRequest{ObjectPath: objectPath})
56
	if err != nil {
57
		fmt.Println("Verification successful: Object no longer exists.")
58
		fmt.Printf("Expected error: %v\n", err)
59
	} else {
60
		fmt.Println("Warning: Object still exists after deletion attempt.")
61
	}
62
}

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
	"net/http"
7
	"os"
8
	"time"
9
10
	Lattice "github.com/anduril/lattice-sdk-go/v4"
11
	"github.com/anduril/lattice-sdk-go/v4/client"
12
	"github.com/anduril/lattice-sdk-go/v4/option"
13
)
14
15
func main() {
16
	// Get environment variables
17
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
18
	clientSecret := os.Getenv("LATTICE_CLIENT_SECRET")
19
	clientId := os.Getenv("LATTICE_CLIENT_ID")
20
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
21
22
	// Check required environment variables
23
	if latticeEndpoint == "" || clientId == "" || clientSecret == "" || sandboxesToken == "" {
24
		fmt.Println("Make sure your Lattice URL and bearer token have been set as system environment variables.")
25
		os.Exit(1)
26
	}
27
28
	// Initialize headers for sandbox authorization
29
	headers := http.Header{}
30
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
31
32
	// Create the client
33
	LatticeClient := client.NewClient(
34
		option.WithClientCredentials(clientId, clientSecret),
35
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
36
		option.WithHTTPHeader(headers),
37
	)
38
39
	// Set the entity ID
40
	entityID := "<ENTITY_ID>"
41
42
	// Create context for the request
43
	ctx := context.Background()
44
45
	// Create empty media array
46
	media := Lattice.Media{
47
		Media: []*Lattice.MediaItem{},
48
	}
49
50
	// Create a provenance object
51
	latestTimestamp := time.Now().UTC()
52
53
	// Create an entity with empty media
54
	entityOverride := Lattice.EntityOverride{
55
		EntityID:  entityID,
56
		FieldPath: "media.media",
57
		Entity: &Lattice.Entity{
58
			EntityID: &entityID,
59
			Media:    &media,
60
		},
61
		Provenance: &Lattice.Provenance{
62
			IntegrationName:  Lattice.String("<your_integration_name>"),
63
			DataType:         Lattice.String("<your_data_type>"),
64
			SourceUpdateTime: Lattice.Time(latestTimestamp),
65
		},
66
	}
67
68
	// Override the entity's media field
69
	_, err := LatticeClient.Entities.OverrideEntity(
70
		ctx,
71
		&entityOverride,
72
	)
73
74
	if err != nil {
75
		fmt.Printf("Exception: %v\n", err)
76
		return
77
	}
78
79
	// Get the entity to verify the media was cleared
80
	entity, err := LatticeClient.Entities.GetEntity(
81
		ctx,
82
		&Lattice.GetEntityRequest{EntityID: entityID},
83
	)
84
85
	if err != nil {
86
		fmt.Printf("Failed to get entity: %v\n", err)
87
		return
88
	}
89
90
	fmt.Printf("Entity: %s\n", *entity.EntityID)
91
	if entity.Media != nil && entity.Media.Media != nil {
92
		fmt.Printf("Media: %v\n", entity.Media.Media)
93
	} else {
94
		fmt.Printf("Media: None\n")
95
	}
96
}