mirror of
https://github.com/gotenberg/gotenberg.git
synced 2026-08-14 19:32:15 +01:00
feat(ExifTool): add capability to overwrite metadata of the PDF generated (#776)
* add new metadata functions to pdf engine interface * add exiftool module with relevant test cases * use exiftool to overwrite metadata in libreoffice * use exiftool to overwrite metadata in chromium * fix linter issues * fix more linter issues * more test cases for better coverage * remove utils * minor changes * remove metadata from pdfoptions * correct indentation * read/write metadata one file at a time.
This commit is contained in:
Piyush Srivastava
committed by
Julien Neuhart
Julien Neuhart
parent
31e7582216
commit
71911cb1a7
8
pkg/modules/exiftool/doc.go
Normal file
8
pkg/modules/exiftool/doc.go
Normal file
@@ -0,0 +1,8 @@
|
||||
// Package exiftool provides an implementation of the gotenberg.PdfEngine
|
||||
// interface using the ExifTool command-line tool. This package allows for reading and
|
||||
// writing of metadata, but does not support the merging of PDF files
|
||||
// nor conversion to specific PDF formats. The path to the exiftool binary must be
|
||||
// specified using the EXIFTOOL_BIN_PATH environment variable.
|
||||
//
|
||||
// See: https://exiftool.org.
|
||||
package exiftool
|
||||
194
pkg/modules/exiftool/exiftool.go
Normal file
194
pkg/modules/exiftool/exiftool.go
Normal file
@@ -0,0 +1,194 @@
|
||||
package exiftool
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
|
||||
"github.com/barasher/go-exiftool"
|
||||
"go.uber.org/zap"
|
||||
|
||||
"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
|
||||
"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
|
||||
)
|
||||
|
||||
func init() {
|
||||
gotenberg.MustRegisterModule(new(ExifTool))
|
||||
}
|
||||
|
||||
// MetadataValueTypeError is constructed when metadata value types cannot be processed.
|
||||
// The underlying library used in this implementation supports the writing of a limited
|
||||
// number of metadata value types.
|
||||
//
|
||||
// For example, according to https://exiftool.org/TagNames/PDF.html metadata can be a boolean,
|
||||
// i.e. "value format... may be string, date, integer, real, boolean or name".
|
||||
// Furthermore, a native boolean type is also supported by JSON and Go. However, the
|
||||
// underlying library does not currently support writing native Go boolean (bool) types.
|
||||
// Therefore, an instance of this struct is created when a boolean metadata entry is supplied.
|
||||
//
|
||||
// The struct contains a key/value map corresponding to individual invalid metadata entries supplied by a consumer.
|
||||
// This allows a helpful error message to be produced for API consumers.
|
||||
// See API.WriteMetadata for more information on valid metadata value types.
|
||||
type MetadataValueTypeError struct {
|
||||
Entries map[string]interface{}
|
||||
}
|
||||
|
||||
// Error returns a helpful error message.
|
||||
func (e *MetadataValueTypeError) Error() string {
|
||||
return fmt.Sprintf("invalid metadata value types supplied - identified by Entries: %s", e.Entries)
|
||||
}
|
||||
|
||||
// GetKeys returns an array of keys with corresponding invalid value types,
|
||||
func (e *MetadataValueTypeError) GetKeys() []string {
|
||||
keys := make([]string, len(e.Entries))
|
||||
i := 0
|
||||
for key := range e.Entries {
|
||||
keys[i] = key
|
||||
i++
|
||||
}
|
||||
return keys
|
||||
}
|
||||
|
||||
// ExifTool abstracts the CLI tool ExifTool and implements the [gotenberg.PdfEngine] interface .
|
||||
type ExifTool struct {
|
||||
binPath string
|
||||
}
|
||||
|
||||
// Descriptor returns ExifTool's module descriptor.
|
||||
func (engine *ExifTool) Descriptor() gotenberg.ModuleDescriptor {
|
||||
return gotenberg.ModuleDescriptor{
|
||||
ID: "exiftool",
|
||||
New: func() gotenberg.Module { return new(ExifTool) },
|
||||
}
|
||||
}
|
||||
|
||||
// Provision sets the module properties. It returns an error if
|
||||
// - the environment variable EXIFTOOL_BIN_PATH is not set
|
||||
// - there is an error creating an instance of exiftool.ExifTool
|
||||
func (engine *ExifTool) Provision(ctx *gotenberg.Context) error {
|
||||
binPath, ok := os.LookupEnv("EXIFTOOL_BIN_PATH")
|
||||
if !ok {
|
||||
return errors.New("EXIFTOOL_BIN_PATH environment variable is not set")
|
||||
}
|
||||
|
||||
engine.binPath = binPath
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Validate validates the module properties.
|
||||
func (engine *ExifTool) Validate() error {
|
||||
_, err := os.Stat(engine.binPath)
|
||||
if os.IsNotExist(err) {
|
||||
return fmt.Errorf("ExifTool binary path does not exist: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Merge is not available in this implementation.
|
||||
func (engine *ExifTool) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
|
||||
return fmt.Errorf("merge PDFs with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
|
||||
}
|
||||
|
||||
// Convert is not available in this implementation.
|
||||
func (engine *ExifTool) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
|
||||
return fmt.Errorf("convert PDF to '%+v' with PDFtk: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
|
||||
}
|
||||
|
||||
// ReadMetadata reads the metadata of the given PDF files.
|
||||
func (engine *ExifTool) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string, metadata map[string]interface{}) error {
|
||||
logger.Debug(fmt.Sprintf("reading metadata of file: %s", inputPath))
|
||||
|
||||
exifTool, err := exiftool.NewExiftool()
|
||||
if err != nil {
|
||||
fmt.Printf("Error intializing ExifTool: %v\n", err)
|
||||
return err
|
||||
}
|
||||
|
||||
fileMetadataInfos := exifTool.ExtractMetadata([]string{inputPath}...)
|
||||
|
||||
if fileMetadataInfos[0].Err != nil {
|
||||
return fmt.Errorf("error reading metadata to following file: %+v", fileMetadataInfos[0])
|
||||
}
|
||||
|
||||
// load into metadata
|
||||
for k, v := range fileMetadataInfos[0].Fields {
|
||||
metadata[k] = v
|
||||
}
|
||||
|
||||
return exifTool.Close()
|
||||
}
|
||||
|
||||
// WriteMetadata write the metadata to the given PDF files.
|
||||
func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
|
||||
logger.Debug(fmt.Sprintf("writing new metadata %s to %s", newMetadata, inputPath))
|
||||
|
||||
exifTool, err := exiftool.NewExiftool()
|
||||
if err != nil {
|
||||
fmt.Printf("Error intializing ExifTool: %v\n", err)
|
||||
return err
|
||||
}
|
||||
|
||||
fileMetadataInfos := exifTool.ExtractMetadata([]string{inputPath}...)
|
||||
|
||||
// there is only file metadata info
|
||||
if fileMetadataInfos[0].Err != nil {
|
||||
return fmt.Errorf("error reading metadata to following file: %+v", fileMetadataInfos[0])
|
||||
}
|
||||
|
||||
// Metadata values can only be specific value types.
|
||||
// An error is returned if metadata with an invalid type is requested.
|
||||
metadataValueErrors := MetadataValueTypeError{
|
||||
Entries: make(map[string]interface{}),
|
||||
}
|
||||
|
||||
// transform metadata
|
||||
for key, value := range newMetadata {
|
||||
switch val := value.(type) {
|
||||
case string:
|
||||
fileMetadataInfos[0].SetString(key, val)
|
||||
case int:
|
||||
fileMetadataInfos[0].SetInt(key, int64(val))
|
||||
case int64:
|
||||
fileMetadataInfos[0].SetInt(key, val)
|
||||
case float32:
|
||||
fileMetadataInfos[0].SetFloat(key, float64(val))
|
||||
case float64:
|
||||
fileMetadataInfos[0].SetFloat(key, val)
|
||||
case []string:
|
||||
fileMetadataInfos[0].SetStrings(key, val)
|
||||
// TODO: support more complex cases, e.g. arrays and nested objects (limitations in underlying library)
|
||||
default:
|
||||
metadataValueErrors.Entries[key] = value
|
||||
}
|
||||
}
|
||||
logger.Debug(fmt.Sprintf("writing metadata %s to %s", fileMetadataInfos[0].Fields, fileMetadataInfos[0].File))
|
||||
|
||||
if len(metadataValueErrors.Entries) > 0 {
|
||||
return api.WrapError(
|
||||
fmt.Errorf("write metadata: %w", err),
|
||||
api.NewSentinelHttpError(
|
||||
http.StatusBadRequest,
|
||||
fmt.Sprintf("Invalid metdata value types supplied by keys '%s'", metadataValueErrors.GetKeys())),
|
||||
)
|
||||
}
|
||||
|
||||
exifTool.WriteMetadata(fileMetadataInfos)
|
||||
|
||||
if fileMetadataInfos[0].Err != nil {
|
||||
return fmt.Errorf("error writing metadata to following file: %+v", fileMetadataInfos[0])
|
||||
}
|
||||
|
||||
return exifTool.Close()
|
||||
}
|
||||
|
||||
// Interface guards.
|
||||
var (
|
||||
_ gotenberg.Module = (*ExifTool)(nil)
|
||||
_ gotenberg.Provisioner = (*ExifTool)(nil)
|
||||
_ gotenberg.Validator = (*ExifTool)(nil)
|
||||
_ gotenberg.PdfEngine = (*ExifTool)(nil)
|
||||
)
|
||||
418
pkg/modules/exiftool/exiftool_test.go
Normal file
418
pkg/modules/exiftool/exiftool_test.go
Normal file
@@ -0,0 +1,418 @@
|
||||
package exiftool
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"go.uber.org/zap"
|
||||
|
||||
"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
|
||||
)
|
||||
|
||||
func TestMetadataValueTypeError_Error(t *testing.T) {
|
||||
instance := MetadataValueTypeError{
|
||||
Entries: map[string]interface{}{
|
||||
"foo": "foo",
|
||||
},
|
||||
}
|
||||
|
||||
assert.True(t, len(instance.Error()) > 0)
|
||||
}
|
||||
|
||||
func TestMetadataValueTypeError_GetKeys(t *testing.T) {
|
||||
for i, tc := range []struct {
|
||||
instance MetadataValueTypeError
|
||||
expect []string
|
||||
}{
|
||||
{
|
||||
instance: MetadataValueTypeError{
|
||||
Entries: map[string]interface{}{},
|
||||
},
|
||||
expect: []string{},
|
||||
},
|
||||
{
|
||||
instance: MetadataValueTypeError{
|
||||
Entries: map[string]interface{}{
|
||||
"foo": "foo",
|
||||
},
|
||||
},
|
||||
expect: []string{"foo"},
|
||||
},
|
||||
{
|
||||
instance: MetadataValueTypeError{
|
||||
Entries: map[string]interface{}{
|
||||
"foo": "foo",
|
||||
"bar": float64(123),
|
||||
"baz": 4.56,
|
||||
"qux": true,
|
||||
"quux": nil,
|
||||
},
|
||||
},
|
||||
expect: []string{"foo", "bar", "baz", "qux", "quux"},
|
||||
},
|
||||
} {
|
||||
actual := tc.instance.GetKeys()
|
||||
|
||||
if !assert.ElementsMatch(t, actual, tc.expect) {
|
||||
t.Errorf("test %d: expected %+v but got: %+v", i, tc.expect, actual)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestExifTool_Descriptor(t *testing.T) {
|
||||
descriptor := new(ExifTool).Descriptor()
|
||||
|
||||
actual := reflect.TypeOf(descriptor.New())
|
||||
expect := reflect.TypeOf(new(ExifTool))
|
||||
|
||||
if actual != expect {
|
||||
t.Errorf("expected '%s' but got '%s'", expect, actual)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExifTool_Provision(t *testing.T) {
|
||||
engine := new(ExifTool)
|
||||
ctx := gotenberg.NewContext(gotenberg.ParsedFlags{}, nil)
|
||||
|
||||
err := engine.Provision(ctx)
|
||||
if err != nil {
|
||||
t.Errorf("expected no error but got: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExifTool_Validate(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
scenario string
|
||||
binPath string
|
||||
expectError bool
|
||||
}{
|
||||
{
|
||||
scenario: "empty bin path",
|
||||
binPath: "",
|
||||
expectError: true,
|
||||
},
|
||||
{
|
||||
scenario: "bin path does not exist",
|
||||
binPath: "/foo",
|
||||
expectError: true,
|
||||
},
|
||||
{
|
||||
scenario: "validate success",
|
||||
binPath: os.Getenv("EXIFTOOL_BIN_PATH"),
|
||||
expectError: false,
|
||||
},
|
||||
} {
|
||||
t.Run(tc.scenario, func(t *testing.T) {
|
||||
engine := new(ExifTool)
|
||||
engine.binPath = tc.binPath
|
||||
err := engine.Validate()
|
||||
|
||||
if !tc.expectError && err != nil {
|
||||
t.Fatalf("expected no error but got: %v", err)
|
||||
}
|
||||
|
||||
if tc.expectError && err == nil {
|
||||
t.Fatal("expected error but got none")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestExiftool_Merge(t *testing.T) {
|
||||
engine := new(ExifTool)
|
||||
err := engine.Merge(context.Background(), zap.NewNop(), nil, "")
|
||||
|
||||
if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
|
||||
t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExiftool_Convert(t *testing.T) {
|
||||
engine := new(ExifTool)
|
||||
err := engine.Convert(context.Background(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")
|
||||
|
||||
if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
|
||||
t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExiftool_ReadMetadata(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
scenario string
|
||||
ctx context.Context
|
||||
inputPath string
|
||||
subset map[string]interface{}
|
||||
expectError bool
|
||||
expectDiff bool
|
||||
}{
|
||||
{
|
||||
scenario: "invalid input path",
|
||||
ctx: context.TODO(),
|
||||
inputPath: "foo",
|
||||
expectError: true,
|
||||
},
|
||||
{
|
||||
scenario: "single file success",
|
||||
ctx: context.TODO(),
|
||||
inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
|
||||
subset: map[string]interface{}{
|
||||
"FileName": "sample1.pdf",
|
||||
"FileTypeExtension": "pdf",
|
||||
"MIMEType": "application/pdf",
|
||||
"PDFVersion": 1.4,
|
||||
"PageCount": float64(3),
|
||||
"CreateDate": "2018:12:06 17:50:06+00:00",
|
||||
"ModifyDate": "2018:12:06 17:50:06+00:00",
|
||||
"Directory": "/tests/test/testdata/pdfengines",
|
||||
"FileType": "PDF",
|
||||
"Linearized": "No",
|
||||
"Creator": "Chromium",
|
||||
"Producer": "Skia/PDF m70",
|
||||
"SourceFile": "/tests/test/testdata/pdfengines/sample1.pdf",
|
||||
},
|
||||
},
|
||||
{
|
||||
scenario: "single file incorrect metadata",
|
||||
ctx: context.TODO(),
|
||||
inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
|
||||
subset: map[string]interface{}{
|
||||
"FileName": "sample1.pdf",
|
||||
"FileTypeExtension": "pdf",
|
||||
"MIMEType": "application/pdf",
|
||||
"PDFVersion": 1.4,
|
||||
"PageCount": float64(3),
|
||||
"CreateDate": "2018:12:06 17:50:06+00:00",
|
||||
"ModifyDate": "2018:12:06 17:50:06+00:00",
|
||||
"Directory": "/tests/test/testdata/pdfengines",
|
||||
"FileType": "PDF",
|
||||
"Linearized": "No",
|
||||
"Creator": "INVALID",
|
||||
"Producer": "Skia/PDF m70",
|
||||
"SourceFile": "/tests/test/testdata/pdfengines/sample1.pdf",
|
||||
},
|
||||
expectDiff: true,
|
||||
},
|
||||
} {
|
||||
t.Run(tc.scenario, func(t *testing.T) {
|
||||
engine := new(ExifTool)
|
||||
err := engine.Provision(nil)
|
||||
if err != nil {
|
||||
t.Fatalf("expected error but got: %v", err)
|
||||
}
|
||||
|
||||
actualMetadata := map[string]interface{}{}
|
||||
err = engine.ReadMetadata(tc.ctx, zap.NewNop(), tc.inputPath, actualMetadata)
|
||||
if !tc.expectError && err != nil {
|
||||
t.Fatalf("expected no error but got: %v", err)
|
||||
}
|
||||
|
||||
if tc.expectError && err == nil {
|
||||
t.Fatal("expected error but got none")
|
||||
}
|
||||
|
||||
if tc.subset != nil && err == nil {
|
||||
if !tc.expectDiff && !isMapSubset(actualMetadata, tc.subset) {
|
||||
t.Errorf("test: %s: expected: %+v to be a subset of: %+v at path: %s",
|
||||
tc.scenario, tc.subset, actualMetadata, tc.inputPath)
|
||||
} else if tc.expectDiff && isMapSubset(actualMetadata, tc.subset) {
|
||||
t.Errorf("test: %s: expected: %+v to be not be a subset of: %+v at path: %s",
|
||||
tc.scenario, tc.subset, actualMetadata, tc.inputPath)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestExiftool_WriteMetadata(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
scenario string
|
||||
ctx context.Context
|
||||
inputPath string
|
||||
newMetadata map[string]interface{}
|
||||
contains map[string]interface{}
|
||||
expectError bool
|
||||
expectDiff bool
|
||||
}{
|
||||
{
|
||||
scenario: "single file success",
|
||||
ctx: context.TODO(),
|
||||
inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
|
||||
newMetadata: map[string]interface{}{
|
||||
"Producer": "foo",
|
||||
},
|
||||
contains: map[string]interface{}{
|
||||
"Producer": "foo",
|
||||
},
|
||||
expectError: false,
|
||||
expectDiff: false,
|
||||
},
|
||||
{
|
||||
scenario: "single file not same metadata",
|
||||
ctx: context.TODO(),
|
||||
inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
|
||||
newMetadata: map[string]interface{}{
|
||||
"Producer": "foo",
|
||||
},
|
||||
contains: map[string]interface{}{
|
||||
"Producer": "foobar",
|
||||
},
|
||||
expectError: false,
|
||||
expectDiff: true,
|
||||
},
|
||||
{
|
||||
scenario: "single file unknown type",
|
||||
ctx: context.TODO(),
|
||||
inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
|
||||
newMetadata: map[string]interface{}{
|
||||
"foo": map[string]string{},
|
||||
},
|
||||
expectError: true,
|
||||
expectDiff: false,
|
||||
},
|
||||
} {
|
||||
t.Run(tc.scenario, func(t *testing.T) {
|
||||
engine := new(ExifTool)
|
||||
err := engine.Provision(nil)
|
||||
if err != nil {
|
||||
t.Fatalf("expected error but got: %v", err)
|
||||
}
|
||||
|
||||
fs := gotenberg.NewFileSystem()
|
||||
outputDir, err := fs.MkdirAll()
|
||||
if err != nil {
|
||||
t.Fatalf("expected error but got: %v", err)
|
||||
}
|
||||
|
||||
defer func() {
|
||||
err = os.RemoveAll(fs.WorkingDirPath())
|
||||
if err != nil {
|
||||
t.Fatalf("expected no error while cleaning up but got: %v", err)
|
||||
}
|
||||
}()
|
||||
|
||||
copyPath := fmt.Sprintf("%s/copy_temp.pdf", outputDir)
|
||||
// open the source file
|
||||
source, err := os.Open(tc.inputPath)
|
||||
if err != nil {
|
||||
t.Fatalf("error in opening file: %v", err)
|
||||
}
|
||||
|
||||
// create the destination file
|
||||
destination, err := os.Create(copyPath)
|
||||
if err != nil {
|
||||
t.Fatalf("error in creating file: %v", err)
|
||||
}
|
||||
|
||||
// copy the contents of source to destination file
|
||||
_, err = io.Copy(destination, source)
|
||||
if err != nil {
|
||||
t.Fatalf("error in copying file: %v", err)
|
||||
}
|
||||
|
||||
err = source.Close()
|
||||
if err != nil {
|
||||
t.Fatalf("error in source file close: %v", err)
|
||||
}
|
||||
err = destination.Close()
|
||||
if err != nil {
|
||||
t.Fatalf("error in destination file close: %v", err)
|
||||
}
|
||||
|
||||
// write metadata to new copy files
|
||||
err = engine.WriteMetadata(tc.ctx, zap.NewNop(), copyPath, tc.newMetadata)
|
||||
if !tc.expectError && err != nil {
|
||||
t.Fatalf("expected no error but got: %v", err)
|
||||
}
|
||||
|
||||
if tc.expectError && err == nil {
|
||||
t.Fatal("expected error but got none")
|
||||
}
|
||||
|
||||
if err == nil {
|
||||
readMetadata := map[string]interface{}{}
|
||||
readErr := engine.ReadMetadata(tc.ctx, zap.NewNop(), copyPath, readMetadata)
|
||||
if tc.contains != nil && readErr == nil {
|
||||
// match metadata
|
||||
if !tc.expectDiff && !isMapSubset(readMetadata, tc.contains) {
|
||||
t.Errorf("test: %s: expected: %+v to be a subset of: %+v at path: %s",
|
||||
tc.scenario, tc.contains, readMetadata, copyPath)
|
||||
} else if tc.expectDiff && isMapSubset(readMetadata, tc.contains) {
|
||||
t.Errorf("test: %s: expected: %+v to be not be a subset of: %+v at path: %s",
|
||||
tc.scenario, tc.contains, readMetadata, copyPath)
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func isMapSubset(mapSet interface{}, mapSubset interface{}) bool {
|
||||
mapSetValue := reflect.ValueOf(mapSet)
|
||||
mapSubsetValue := reflect.ValueOf(mapSubset)
|
||||
|
||||
if mapSetValue.Kind() != reflect.Map || mapSubsetValue.Kind() != reflect.Map {
|
||||
return false
|
||||
}
|
||||
if reflect.TypeOf(mapSetValue) != reflect.TypeOf(mapSubsetValue) {
|
||||
return false
|
||||
}
|
||||
if len(mapSubsetValue.MapKeys()) == 0 {
|
||||
return true
|
||||
}
|
||||
|
||||
iterMapSubset := mapSubsetValue.MapRange()
|
||||
|
||||
for iterMapSubset.Next() {
|
||||
k := iterMapSubset.Key()
|
||||
v := iterMapSubset.Value()
|
||||
|
||||
v2 := mapSetValue.MapIndex(k)
|
||||
|
||||
if !v2.IsValid() {
|
||||
return false
|
||||
}
|
||||
if isValueKind(v, reflect.Slice) && isValueKind(v2, reflect.Slice) {
|
||||
vSlice := convertSlice(v)
|
||||
v2Slice := convertSlice(v2)
|
||||
if !equal(vSlice, v2Slice) {
|
||||
return false
|
||||
}
|
||||
} else if v.Interface() != v2.Interface() {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
func isValueKind(value reflect.Value, kind reflect.Kind) bool {
|
||||
return reflect.TypeOf(value.Interface()).Kind() == kind
|
||||
}
|
||||
|
||||
func convertSlice(value reflect.Value) []interface{} {
|
||||
slice := make([]interface{}, reflect.ValueOf(value.Interface()).Len())
|
||||
for i := range slice {
|
||||
slice = append(slice, reflect.ValueOf(value.Interface()).Index(i).Interface())
|
||||
}
|
||||
return slice
|
||||
}
|
||||
|
||||
// equal tells whether a and b contain the same elements.
|
||||
// A nil argument is equivalent to an empty slice.
|
||||
func equal(a, b []interface{}) bool {
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
for i, v := range a {
|
||||
if v != b[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
Reference in New Issue
Block a user