Merge pull request #6 from nyudlts/chore/tweak-instance

add modifications to support ADOC functionality

ArchivalObjects.go

@@ -26,10 +26,16 @@ func (a *ASClient) GetArchivalObjectIDs(repositoryID int) ([]int, error) {
 
 func (a *ASClient) GetArchivalObject(repositoryId int, aoId int) (ArchivalObject, error) {
 
+	aoURI := fmt.Sprintf("/repositories/%d/archival_objects/%d", repositoryId, aoId)
+
+	return a.GetArchivalObjectFromURI(aoURI)
+}
+
+func (a *ASClient) GetArchivalObjectFromURI(aoURI string) (ArchivalObject, error) {
+
 	ao := ArchivalObject{}
-	endpoint := fmt.Sprintf("/repositories/%d/archival_objects/%d", repositoryId, aoId)
 
-	reponse, err := a.get(endpoint, true)
+	reponse, err := a.get(aoURI, true)
 	if err != nil {
 		return ao, err
 	}

ArchivalObjects_test.go

@@ -31,7 +31,7 @@ func TestArchivalObject(t *testing.T) {
 		if err != nil {
 			t.Error(err)
 		} else {
-			t.Logf("Successfully requested and serialized archival %s: %s\n", ao.URI, ao.Title)
+			t.Logf("Successfully requested and serialized archival object %s: %s\n", ao.URI, ao.Title)
 		}
 	})
 

CHANGELOG.md

@@ -0,0 +1,20 @@
+## CHANGELOG
+
+#### v0.6.0
+  - add `...FromURI()` functions:
+    - add `GetArchivalObjectFromURI()`
+    - add `GetDigitalObjectFromURI()`
+    - add `DeleteDigitalObjectFromURI()`
+    - add `GetDigitalObjectIDsForArchivalObjectFromURI()`
+  - refactor `...Object()` functions to use `...FromURI()` functions
+    - refactor `GetArchivalObject()` to use `GetArchivalObjectFromURI()`
+    - refactor `GetDigitalObject()` to use `GetDigitalObjectFromURI()`
+    - refactor `DeleteDigitalObject()` to use `DeleteDigitalObjectFromURI()`
+  - add helper type and function
+    - add `CreateOrUpdateResponse` type
+    - add `ParseCreateOrUpdateResponse()`
+  - force `bool` key/value pairs to always be sent in marshaled JSON for selected types
+    - remove `omitempty` option from `DigitalObject` type `bool` JSON tags
+    - remove `omitempty` option from `FileVersion` type `bool` JSON tags
+
+

Common.go

@@ -11,7 +11,7 @@ import (
 	"time"
 )
 
-var LibraryVersion = "v0.3.14b"
+var LibraryVersion = "v0.6.0"
 
 var seed = rand.NewSource(time.Now().UnixNano())
 var rGen = rand.New(seed)
@@ -114,3 +114,22 @@ func containsInt(list []int, id int) bool {
 	}
 	return false
 }
+
+type CreateOrUpdateResponse struct {
+	Status      string   `json:"status"`
+	Error       string   `json:"error"`
+	ID          int      `json:"id,omitempty"`
+	LockVersion int      `json:"lock_version,omitempty"`
+	Stale       bool     `json:"stale,omitempty"`
+	URI         string   `json:"uri,omitempty"`
+	Warnings    []string `json:"warnings,omitempty"`
+}
+
+func ParseCreateOrUpdateResponse(body string) *CreateOrUpdateResponse {
+	var cour CreateOrUpdateResponse
+	err := json.Unmarshal([]byte(body), &cour)
+	if err != nil {
+		return nil
+	}
+	return &cour
+}

Common_test.go

@@ -2,8 +2,10 @@ package aspace
 
 import (
 	"flag"
-	goaspacetest "github.com/nyudlts/go-aspace/goaspace_testing"
+	"strconv"
 	"testing"
+
+	goaspacetest "github.com/nyudlts/go-aspace/goaspace_testing"
 )
 
 func TestCommon(t *testing.T) {
@@ -33,4 +35,47 @@ func TestCommon(t *testing.T) {
 			t.Log("Succesfully requested valid session key.")
 		}
 	})
+
+	t.Run("Test ParseCreateOrUpdateResponse() Created", func(t *testing.T) {
+
+		responseBody := `{"status":"Created","id":61344,"lock_version":0,"stale":true,"uri":"/repositories/6/digital_objects/61344","warnings":[]}`
+		got := ParseCreateOrUpdateResponse(responseBody)
+
+		scenarios := [][]string{
+			{"Created", got.Status, "Incorrect Status"},
+			{"", got.Error, "Incorrect Error"},
+			{"61344", strconv.FormatInt(int64(got.ID), 10), "Incorrect ID"},
+			{"0", strconv.FormatInt(int64(got.LockVersion), 10), "Incorrect LockVersion"},
+			{"true", strconv.FormatBool(got.Stale), "Incorrect Stale"},
+			{"/repositories/6/digital_objects/61344", got.URI, "Incorrect URI"},
+		}
+
+		for _, scenario := range scenarios {
+			if scenario[1] != scenario[0] {
+				t.Errorf("unexpected result: %s: want: '%s', got: '%s'", scenario[2], scenario[0], scenario[1])
+			}
+		}
+	})
+
+	t.Run("Test ParseCreateOrUpdateResponse() Error", func(t *testing.T) {
+
+		responseBody := `{"error":"I need more coffee!"}`
+		got := ParseCreateOrUpdateResponse(responseBody)
+
+		scenarios := [][]string{
+			{"", got.Status, "Incorrect Status"},
+			{"I need more coffee!", got.Error, "Incorrect Error"},
+			{"0", strconv.FormatInt(int64(got.ID), 10), "Incorrect ID"},
+			{"0", strconv.FormatInt(int64(got.LockVersion), 10), "Incorrect LockVersion"},
+			{"false", strconv.FormatBool(got.Stale), "Incorrect Stale"},
+			{"", got.URI, "Incorrect URI"},
+		}
+
+		for _, scenario := range scenarios {
+			if scenario[1] != scenario[0] {
+				t.Errorf("unexpected result: %s: want: '%s', got: '%s'", scenario[2], scenario[0], scenario[1])
+			}
+		}
+	})
+
 }

DigitalObjects.go

@@ -23,9 +23,14 @@ func (a *ASClient) GetDigitalObjectIDs(repositoryId int) ([]int, error) {
 }
 
 func (a *ASClient) GetDigitalObject(repositoryId int, daoId int) (DigitalObject, error) {
+	doURI := fmt.Sprintf("/repositories/%d/digital_objects/%d", repositoryId, daoId)
+
+	return a.GetDigitalObjectFromURI(doURI)
+}
+
+func (a *ASClient) GetDigitalObjectFromURI(doURI string) (DigitalObject, error) {
 	do := DigitalObject{}
-	endpoint := fmt.Sprintf("/repositories/%d/digital_objects/%d", repositoryId, daoId)
-	response, err := a.get(endpoint, true)
+	response, err := a.get(doURI, true)
 	if err != nil {
 		return do, err
 	}
@@ -80,8 +85,13 @@ func (a *ASClient) CreateDigitalObject(repositoryId int, dao DigitalObject) (str
 }
 
 func (a *ASClient) DeleteDigitalObject(repositoryId int, doId int) (string, error) {
-	endpoint := fmt.Sprintf("/repositories/%d/digital_objects/%d", repositoryId, doId)
-	response, err := a.delete(endpoint)
+	doURI := fmt.Sprintf("/repositories/%d/digital_objects/%d", repositoryId, doId)
+
+	return a.DeleteDigitalObjectFromURI(doURI)
+}
+
+func (a *ASClient) DeleteDigitalObjectFromURI(doURI string) (string, error) {
+	response, err := a.delete(doURI)
 	if err != nil {
 		return "", err
 	}
@@ -145,3 +155,20 @@ func (do DigitalObject) ContainsUseStatement(role string) bool {
 	}
 	return false
 }
+
+func (a *ASClient) GetDigitalObjectIDsForArchivalObjectFromURI(aoURI string) ([]string, error) {
+	doURIs := []string{}
+
+	ao, err := a.GetArchivalObjectFromURI(aoURI)
+	if err != nil {
+		return doURIs, err
+	}
+
+	for _, instance := range ao.Instances {
+		if instance.InstanceType == "digital_object" {
+			doURIs = append(doURIs, instance.DigitalObject["ref"])
+		}
+	}
+
+	return doURIs, nil
+}

DigitalObjects_test.go

@@ -2,9 +2,10 @@ package aspace
 
 import (
 	"flag"
-	"fmt"
-	goaspacetest "github.com/nyudlts/go-aspace/goaspace_testing"
+	"slices"
 	"testing"
+
+	goaspacetest "github.com/nyudlts/go-aspace/goaspace_testing"
 )
 
 func TestDigitalObject(t *testing.T) {
@@ -18,24 +19,71 @@ func TestDigitalObject(t *testing.T) {
 		repositoryID, digitalObjectID, err := client.GetRandomDigitalObject()
 		if err != nil {
 			t.Error(err)
+			t.FailNow()
 		}
 
 		do, err := client.GetDigitalObject(repositoryID, digitalObjectID)
 		if err != nil {
 			t.Error(err)
+			t.FailNow()
 		} else {
-			t.Log(fmt.Sprintf("Successfully requested and serialized digital object %s %s\n", do.URI, do.Title))
+			t.Logf("Successfully requested and serialized digital object %s %s\n", do.URI, do.Title)
+		}
+
+	})
+
+	t.Run("Test serialize a digital object using doURI", func(t *testing.T) {
+		doURI := "/repositories/3/digital_objects/45726"
+		do, err := client.GetDigitalObjectFromURI(doURI)
+		if err != nil {
+			t.Error(err)
+			t.FailNow()
 		}
+
+		want := "MSS_407_cuid29413B"
+		if do.DigitalObjectID != want {
+			t.Errorf("Expected %s but got %s", want, do.DigitalObjectID)
+			t.FailNow()
+		}
+		t.Logf("Successfully requested and serialized digital object via doURI %s %s\n", do.URI, do.Title)
 	})
 
-	t.Run("Test Unamarshal a digital object with notes", func(t *testing.T) {
+	t.Run("Test Unmarshal a digital object with notes", func(t *testing.T) {
 
 		do, err := client.GetDigitalObject(2, 261)
 		if err != nil {
 			t.Error(err)
 		} else {
 			t.Log(do.Notes)
-			t.Log(fmt.Sprintf("Successfully requested and serialized digital object %s %s\n", do.URI, do.Title))
+			t.Logf("Successfully requested and serialized digital object %s %s\n", do.URI, do.Title)
+		}
+	})
+
+	t.Run("Test DigitalObjectIDs from an ArchivalObject", func(t *testing.T) {
+
+		aoURI := "/repositories/3/archival_objects/912180"
+
+		got, err := client.GetDigitalObjectIDsForArchivalObjectFromURI(aoURI)
+		if err != nil {
+			t.Error(err)
+			t.FailNow()
+		}
+
+		want := []string{"/repositories/3/digital_objects/45716", "/repositories/3/digital_objects/45726", "/repositories/3/digital_objects/45717"}
+		if len(want) != len(got) {
+			t.Errorf("expected %d digital objects but got %d", len(want), len(got))
+			t.FailNow()
+		}
+
+		slices.Sort(want)
+		slices.Sort(got)
+
+		for i, w := range want {
+			if w != got[i] {
+				t.Errorf("expected %s but got %s", w, got[i])
+				t.FailNow()
+			}
 		}
+		t.Logf("Successfully retrieved DigitalObjectIDs for archival object: %s\n", aoURI)
 	})
 }

Models.go

@@ -187,7 +187,7 @@ type Deaccession struct {
 	Scope         string   `json:"scope,omitempty"`
 	Description   string   `json:"description,omitempty"`
 	Date          Date     `json:"date,omitempty"`
-	Reason        string   `json:"reason,omitempty,omitempty"`
+	Reason        string   `json:"reason,omitempty"`
 	Disposition   string   `json:"disposition,omitempty"`
 	Notification  bool     `json:"notification,omitempty"`
 	Extents       []Extent `json:"extents,omitempty"`
@@ -198,10 +198,10 @@ type DigitalObject struct {
 	LockVersion          *int                   `json:"lock_version,omitempty"`
 	DigitalObjectID      string                 `json:"digital_object_id,omitempty"`
 	Title                string                 `json:"title,omitempty"`
-	Publish              bool                   `json:"publish,omitempty"`
-	Restrictions         bool                   `json:"restrictions,omitempty"`
-	Suppressed           bool                   `json:"suppressed,omitempty"`
-	IsSlugAuto           bool                   `json:"is_slug_auto,omitempty"`
+	Publish              bool                   `json:"publish"`
+	Restrictions         bool                   `json:"restrictions"`
+	Suppressed           bool                   `json:"suppressed"`
+	IsSlugAuto           bool                   `json:"is_slug_auto"`
 	JSONModelType        string                 `json:"jsonmodel_type,omitempty"`
 	ExternalIds          []ExternalID           `json:"external_ids,omitempty"`
 	Subjects             []SubjectReference     `json:"subjects,omitempty"`
@@ -270,7 +270,7 @@ type FileVersion struct {
 	Identifier            string `json:"identifier,omitempty"`
 	LockVersion           int    `json:"lock_version,omitempty"`
 	FileURI               string `json:"file_uri,omitempty"`
-	Publish               bool   `json:"publish,omitempty"`
+	Publish               bool   `json:"publish"`
 	FileFormatVersion     string `json:"file_format_version,omitempty"`
 	FileSizeBytes         uint64 `json:"file_size_bytes,omitempty"`
 	Checksum              string `json:"checksum,omitempty"`
@@ -281,7 +281,7 @@ type FileVersion struct {
 	XLinkShowAttribute    string `json:"xlink_show_attribute,omitempty"`
 	FileFormatName        string `json:"file_format_name,omitempty"`
 	JSONModelType         string `json:"jsonmodel_type,omitempty"`
-	IsRepresentative      bool   `json:"is_representative,omitempty"`
+	IsRepresentative      bool   `json:"is_representative"`
 }
 
 type Instance struct {

README.md

@@ -1,4 +1,4 @@
-# go-aspace v0.3.14b
+# go-aspace v0.6.0
 a Go library for ArchivesSpace integrations
 
 ## Use
@@ -57,4 +57,4 @@ to run the test suite
 ```shell
 go test -v --config /path/to/go-aspace.yml --environment the-environment-to-use
 ```
-The test suite will select random objects from the specified aspace instance, which may fail serialization to go structs
+The test suite will select random objects from the specified aspace instance, which may fail serialization to go structs