box

package module
v0.1.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 25, 2026 License: MIT Imports: 20 Imported by: 0

README

go-box

GoVersion GoDoc License Report

go-box is a Go client library for accessing the Box.com API.

Installation

go get github.com/gildas/go-box

Usage

After importing the package in your code:

import "github.com/gildas/go-box"

You can create a new client with:

client := box.NewClient(context)
Authentication

To let the client authenticate with nox.com, you need to provide credentials and authenticate:

client := box.NewClient(context)
creds := box.Credentials{
	ClientID:     "your-client-id",
	ClientSecret: "your-client-secret",
	EnterpriseID: "your-enterprise-id",
	AppAuth: box.AppAuth{
		PublicKeyID: "your-public-key-id",
		PrivateKey:  "your-private-key",
		PassPhrase: "your-passphrase",
	},
}
if err := client.Authenticate(creds); err != nil {
	log.Errorf("Failed to authenticate.", err)
}
Uploading a file

To upload a file you need to know the owner Id of the folder you want to upload the file to:

import "github.com/gildas/go-box"
import "github.com/gildas/go-logger"
import "github.com/gildas/go-request"

func UploadFile(context context.Context, client *box.Client, ownerID string, filename string, reader io.Reader) (*box.FileCollection, error) {
	log := logger.Must(logger.FromContext(context)).Child("box", "upload", "owner", ownerID)

	// Get the folder for the owner
	log.Debugf("Getting the folder for the owner.")
	folder, err := client.Folders.FindByName(context, ownerID)
	if err != nil {
		log.Errorf("Failed to get the folder for the owner.", err)
		return nil, err
	}

	return client.Files.Upload(context, &box.UploadOptions{
		Filename: filename,
		Parent:   folder.AsPathEntry(),
		Content:  request.ContentFromReader(reader),
	})
}

You can also upload payloads directly:

files, err := client.Files.Upload(context, &box.UploadOptions{
	Parent:   folder.AsPathEntry(),
	Filename: "test.json",
	Payload: struct {
		Name string `json:"name"`
	}{
		Name: "Test",
	},
})
Finding files

To find files, you can use the Find methods:

root, err := client.Folders.FindByID(context, "0")
entry, err := client.Files.FindByName(context, "test.json", root.AsPathEntry())

You can also find files by Id (coming from a previous upload, for example):

root, err := client.Folders.FindByID(context, "0")
entry, err := client.Files.FindByID(context, "1234567890", root.AsPathEntry())
Downloading a file

To download a file, you need the entry (see above):

downloaded, err := client.Files.Download(context, root.ItemCollection.Paths[0])

downloaded is a request.Content that you can use to read the content of the file.

Deleting a file

To delete a file:

err = client.Folders.Delete(context, root.ItemCollection.Paths[0])
Creating a folder

To create a folder, you need their parent folder:

root, err := client.Folders.FindByID(context, "0")
folder, err := client.Folders.Create(context, &box.FolderEntry{Name: "New Folder", Parent: root.AsPathEntry()})
Finding a folder

To find a folder, you can use the Find methods:

root, err := client.Folders.FindByID(context, "0")
entry, err := client.Folders.FindByName(context, "New Folder", root.AsPathEntry())

You can also find folders by Id (coming from a previous creation, for example):

root, err := client.Folders.FindByID(context, "0")
entry, err := client.Folders.FindByID(context, "1234567890", root.AsPathEntry())
Deleting a folder

To delete a folder:

err = client.Folders.Delete(context, root.ItemCollection.Paths[0])

To create a shared link:

link, err := client.SharedLinks.Create(context, &entry, nil)

You can also give some options to the shared link:

link, err := client.SharedLinks.Create(context, &entry, &box.SharedLinkOptions{
	Access: "open",
	Permissions: box.SharedLinkPermissions{
		CanDownload: true,
	},
	UnsharedAt: time.Now().Add(24 * time.Hour),
})
Logging

go-box uses go-logger for logging. The logs are bunyan compatible. You can either use the bunyan CLI to read them or use the lv tool to read them.

If you don't provider a logger, the client will create one for you that logs to os.Stderr with the INFO level.

To provide your own logger, you can do something like this (please have a look at go-logger for more information):

log := logger.Create("myapp", &logger.FileStream{Path: "myapp.log", FilterLevels: logger.NewLevelSet(logger.DEBUG)})
defer log.Flush()

client := box.NewClient(log.ToContext(context))

Documentation

Index

Constants

View Source 
const TokenContextKey key = iota

TokenContextKey is the key for the token stored in a context.Context

Variables

View Source 
var (
	BadRequest                             = RequestError{Type: "error", ID: "bad_request", StatusCode: 400, Message: "Bad Request"}
	ItemNameInvalid                        = RequestError{Type: "error", ID: "item_name_invalid", StatusCode: 400, Message: "Item name invalid"}
	TermsOfServiceRequired                 = RequestError{Type: "error", ID: "terms_of_service_required", StatusCode: 400, Message: "User must accept custom terms of service before action can be taken"}
	RequestedPreviewUnavailable            = RequestError{Type: "error", ID: "requested_preview_unavailable", StatusCode: 400, Message: "Requested preview unavailable"}
	FolderNotEmpty                         = RequestError{Type: "error", ID: "folder_not_empty", StatusCode: 400, Message: "Cannot delete – folder not empty"}
	InvalidGrant                           = RequestError{Type: "error", ID: "invalid_grant", StatusCode: 420, Message: "Please check the 'iss' claim. The client id specified is invalid."}
	InvalidPrivateKey                      = RequestError{Type: "error", ID: "invalid_private_key", StatusCode: 400, Message: "Invalid Private Key in request"}
	InvalidRequestParameters               = RequestError{Type: "error", ID: "invalid_request_parameters", StatusCode: 400, Message: "Invalid input parameters in request"}
	UserAlreadyCollaborator                = RequestError{Type: "error", ID: "user_already_collaborator", StatusCode: 400, Message: "User is already a collaborator"}
	CannotMakeCollaboratedSubfolderPrivate = RequestError{Type: "error", ID: "cannot_make_collaborated_subfolder_private", StatusCode: 400, Message: "Cannot move a collaborated subfolder to a private folder unless the new owner is explicitly specified"}
	ItemNameTooLong                        = RequestError{Type: "error", ID: "item_name_too_long", StatusCode: 400, Message: "Item name too long"}
	CollaborationsNotAvailableOnRootFolder = RequestError{Type: "error", ID: "collaborations_not_available_on_root_folder", StatusCode: 400, Message: "Root folder cannot be collaborated"}
	SyncItemMoveFailure                    = RequestError{Type: "error", ID: "sync_item_move_failure", StatusCode: 400, Message: "Cannot move a synced item"}
	RequestedPageOutOfRange                = RequestError{Type: "error", ID: "requested_page_out_of_range", StatusCode: 400, Message: "Requested representation page out of range"}
	CyclicalFolderStructure                = RequestError{Type: "error", ID: "cyclical_folder_structure", StatusCode: 400, Message: "Folder move creates cyclical folder structure"}
	BadDigest                              = RequestError{Type: "error", ID: "bad_digest", StatusCode: 400, Message: "The specified Content-MD5 did not match what we received"}
	InvalidCollaborationItem               = RequestError{Type: "error", ID: "invalid_collaboration_item", StatusCode: 400, Message: "Item type must be specified and set to ‘folder’"}
	TaskAssigneeNotAllowed                 = RequestError{Type: "error", ID: "task_assignee_not_allowed", StatusCode: 400, Message: "Assigner does not have sufficient privileges to assign task to assignee"}
	InvalidStatus                          = RequestError{Type: "error", ID: "invalid_status", StatusCode: 400, Message: "You can change the status only if the collaboration is pending"}
	Forbidden                              = RequestError{Type: "error", ID: "forbidden", StatusCode: 403, Message: "Forbidden"}
	StorageLimitExceeded                   = RequestError{Type: "error", ID: "storage_limit_exceeded", StatusCode: 403, Message: "Account storage limit reached"}
	CorsOriginNotWhitelisted               = RequestError{Type: "error", ID: "cors_origin_not_whitelisted", StatusCode: 403, Message: "You’re attempting to make a request from a domain that is not whitelisted in your app’s cors configuration"}
	AccessDeniedInsufficientPermissions    = RequestError{Type: "error", ID: "access_denied_insufficient_permissions", StatusCode: 403, Message: "Access denied – insufficient permission"}
	AccessDeniedItemLocked                 = RequestError{Type: "error", ID: "access_denied_item_locked", StatusCode: 403, Message: "Access Denied, item locked"}
	FileSizeLimitExceeded                  = RequestError{Type: "error", ID: "file_size_limit_exceeded", StatusCode: 403, Message: "File size exceeds the folder owner’s file size limit"}
	IncorrectSharedItemPassword            = RequestError{Type: "error", ID: "incorrect_shared_item_password", StatusCode: 403, Message: "Incorrect Shared Item Password"}
	AccessFromLocationBlocked              = RequestError{Type: "error", ID: "access_from_location_blocked", StatusCode: 403, Message: "You’re attempting to log in to Box from a location that has not been approved by your admin. Please talk to your admin to resolve this issue."}
	NotFound                               = RequestError{Type: "error", ID: "not_found", StatusCode: 404, Message: "When the item is not found, or if the user does not have access to the item."}
	PreviewCannotBeGenerated               = RequestError{Type: "error", ID: "preview_cannot_be_generated", StatusCode: 404, Message: "Preview cannot be generated"}
	Trashed                                = RequestError{Type: "error", ID: "trashed", StatusCode: 404, Message: "Item is trashed"}
	NotTrashed                             = RequestError{Type: "error", ID: "not_trashed", StatusCode: 404, Message: "Item is not trashed"}
	MethodNotAllowed                       = RequestError{Type: "error", ID: "method_not_allowed", StatusCode: 405, Message: "Method Not Allowed"}
	ItemNameInUse                          = RequestError{Type: "error", ID: "item_name_in_use", StatusCode: 409, Message: "Item with the same name already exists"}
	Conflict                               = RequestError{Type: "error", ID: "conflict", StatusCode: 409, Message: "A resource with this value already exists"}
	UserLoginAlreadyUsed                   = RequestError{Type: "error", ID: "user_login_already_used", StatusCode: 409, Message: "User with the specified login already exists"}
	RecentSimilarComment                   = RequestError{Type: "error", ID: "recent_similar_comment", StatusCode: 409, Message: "A similar comment has been made recently"}
	OperationBlockedTemporary              = RequestError{Type: "error", ID: "operation_blocked_temporary", StatusCode: 409, Message: "The operation is blocked by another ongoing operation."}
	NameTemporarilyReserved                = RequestError{Type: "error", ID: "name_temporarily_reserved", StatusCode: 409, Message: "Two duplicate requests have been submitted at the same time. Box acknowledges the first and reserves the name, but a second duplicate request arrives before the first request has completed."}
	SyncStatePreconditionFailed            = RequestError{Type: "error", ID: "sync_state_precondition_failed", StatusCode: 412, Message: "The resource has been modified. Please retrieve the resource again and retry"}
	PreconditionFailed                     = RequestError{Type: "error", ID: "precondition_failed", StatusCode: 412, Message: "The resource has been modified. Please retrieve the resource again and retry"}
	RateLimitExceeded                      = RequestError{Type: "error", ID: "rate_limit_exceeded", StatusCode: 429, Message: "Request rate limit exceeded, please try again later. There are two limits. The first is a limit of 10 API calls per second per user. The second limit is 4 uploads per second per user."}
	InternalServerError                    = RequestError{Type: "error", ID: "internal_server_error", StatusCode: 500, Message: "Internal Server Error"}
	UnavailableError                       = RequestError{Type: "error", ID: "unavailable", StatusCode: 503, Message: "Unavailable"}
)
View Source 
var VERSION = "0.2.1" + commit

VERSION is the version of this application

Functions

This section is empty.

Types

type AppAuth 

type AppAuth struct {
	PublicKeyID string `json:"publickeyId"`
	PrivateKey  string `json:"privateKey"`
	Passphrase  string `json:"passphrase"`
}

AppAuth is used to authenticate an application

type Auth 

type Auth struct {
	*Client

	Token *Token
	// contains filtered or unexported fields
}

Auth module

func (*Auth) Authenticate 

func (module *Auth) Authenticate(ctx context.Context, creds Credentials) (err error)

Authenticate authenticates with the given credentials Currently only AppAuth is supported

func (*Auth) IsAuthenticated 

func (module *Auth) IsAuthenticated() bool

IsAuthenticated tells if the client is authenticated

type Client 

type Client struct {
	Api         *url.URL       `json:"api"`
	Proxy       *url.URL       `json:"proxy"`
	Auth        *Auth          `json:"-"`
	Files       *Files         `json:"-"`
	Folders     *Folders       `json:"-"`
	SharedLinks *SharedLinks   `json:"-"`
	Logger      *logger.Logger `json:"-"`
}

Client is the Box Client

func NewClient 

func NewClient(ctx context.Context) *Client

NewClient instantiates a new Client

func (*Client) IsAuthenticated 

func (client *Client) IsAuthenticated() bool

IsAuthenticated tells if the client is authenticated

type ContextInfo 

type ContextInfo struct {
	// TODO: Find the best representation of this thing
	// https://developer.box.com/reference is not clear if it is errors or conflicts
	Errors []byte `json:"errors"`
}

ContextInfo gives some contextual information about the current error

type Credentials 

type Credentials struct {
	ClientID     string  `json:"clientId"`
	ClientSecret string  `json:"clientSecret"`
	AppAuth      AppAuth `json:"appAuth"`
	EnterpriseID string  `json:"enterpriseId,omitempty"`
}

Credentials represents the Authentication information

func (*Credentials) MarshalJSON 

func (creds *Credentials) MarshalJSON() ([]byte, error)

MarshalJSON marshals into JSON

func (*Credentials) UnmarshalJSON 

func (creds *Credentials) UnmarshalJSON(payload []byte) (err error)

UnmarshalJSON unmarshals JSON into this

type DownloadOptions 

type DownloadOptions struct {
	Parent      *PathEntry
	Filename    string
	ContentType string
	Content     []byte
	Payload     interface{}
}

DownloadOptions contains the options for downloading data

type FileCollection 

type FileCollection struct {
	Count int         `json:"total_count"`
	Files []FileEntry `json:"entries"`
}

FileCollection represents a collection of FileEntry

type FileEntry 

type FileEntry struct {
	Type              string         `json:"type"`
	ID                string         `json:"id"`
	Name              string         `json:"name"`
	Description       string         `json:"description"`
	ETag              string         `json:"etag"`
	SequenceID        string         `json:"sequence_id"`
	Size              int64          `json:"size"`
	ItemStatus        string         `json:"item_status"`
	SharedLink        *SharedLink    `json:"shared_link,omitempty"`
	Checksum          string         `json:"sha1"`
	FileVersion       FileVersion    `json:"file_version"`
	Parent            PathEntry      `json:"parent"`
	Paths             PathCollection `json:"path_collection"`
	CreatedAt         time.Time      `json:"-"`
	ModifiedAt        time.Time      `json:"-"`
	TrashedAt         time.Time      `json:"-"`
	PurgedAt          time.Time      `json:"-"`
	ContentCreatedAt  time.Time      `json:"-"`
	ContentModifiedAt time.Time      `json:"-"`
	CreatedBy         UserEntry      `json:"created_by"`
	ModifiedBy        UserEntry      `json:"modified_by"`
	OwnedBy           UserEntry      `json:"owned_by"`
}

FileEntry represents a File Entry

func (FileEntry) MarshalJSON 

func (file FileEntry) MarshalJSON() ([]byte, error)

MarshalJSON marshals this into JSON

func (*FileEntry) UnmarshalJSON 

func (file *FileEntry) UnmarshalJSON(payload []byte) (err error)

UnmarshalJSON decodes JSON

type FileVersion 

type FileVersion struct {
	Type     string `json:"type"`
	ID       string `json:"id"`
	Checksum string `json:"sha1"`
}

FileVersion represents the version of a FileEntry

type Files 

type Files struct {
	*Client
	// contains filtered or unexported fields
}

Files module

func (*Files) CreateUploadSession 

func (module *Files) CreateUploadSession(
	ctx context.Context,
	options *UploadSessionOptions,
) (*UploadSession, error)

func (*Files) Download 

func (module *Files) Download(ctx context.Context, entry *FileEntry, options *request.Options) (*request.Content, error)

Download download the content of a file (by its FileEntry)

func (*Files) FindByID 

func (module *Files) FindByID(ctx context.Context, fileID string) (*FileEntry, error)

FindByID retrieves a file by its id

func (*Files) FindByName 

func (module *Files) FindByName(ctx context.Context, name string, parentId string) (*FileEntry, error)

FindByName retrieves a file by its name For now, exact match and 1 level (no recursion)

func (*Files) Upload 

func (module *Files) Upload(ctx context.Context, options *UploadOptions, reqOpts *request.Options) (*FileCollection, error)

Upload uploads data to Box.com

type FolderCollection 

type FolderCollection struct {
	Count   int           `json:"total_count"`
	Folders []FolderEntry `json:"entries"`
}

FolderCollection represents a collection of FolderEntry

type FolderEntry 

type FolderEntry struct {
	Type           string         `json:"type"`
	ID             string         `json:"id"`
	Name           string         `json:"name"`
	Description    string         `json:"description"`
	ETag           string         `json:"etag"`
	SequenceID     string         `json:"sequence_id"`
	Size           int64          `json:"size"`
	ItemStatus     string         `json:"item_status"`
	SharedLink     *SharedLink    `json:"shared_link,omitempty"`
	Checksum       string         `json:"sha1"`
	FileVersion    FileVersion    `json:"file_version"`
	Parent         *PathEntry     `json:"parent"`
	Paths          PathCollection `json:"path_collection"`
	ItemCollection PathCollection `json:"item_collection"`
	Tags           []string       `json:"tags"`
	SyncState      string         `json:"sync_state"`

	CreatedAt         time.Time `json:"-"`
	ModifiedAt        time.Time `json:"-"`
	TrashedAt         time.Time `json:"-"`
	PurgedAt          time.Time `json:"-"`
	ContentCreatedAt  time.Time `json:"-"`
	ContentModifiedAt time.Time `json:"-"`
	CreatedBy         UserEntry `json:"created_by"`
	ModifiedBy        UserEntry `json:"modified_by"`
	OwnedBy           UserEntry `json:"owned_by"`

	AllowedSharedLinkAccessLevels         []string `json:"allowed_shared_link_access_levels"`
	AllowedInviteeRoles                   []string `json:"allowed_invitee_roles"`
	HasCollaborations                     bool     `json:"has_collaborations"`
	CanNonOwnersInvite                    bool     `json:"can_non_owners_invite"`
	IsExternallyOwned                     bool     `json:"is_externally_owned"`
	IsCollaborationRestrictedToEnterprise bool     `json:"is_collaboration_restricted_to_enterprise"`
}

FolderEntry represents a File Entry

func (*FolderEntry) AsPathEntry 

func (folder *FolderEntry) AsPathEntry() *PathEntry

AsPathEntry gets a PathEntry from the current FolderEntry

func (FolderEntry) MarshalJSON 

func (folder FolderEntry) MarshalJSON() ([]byte, error)

MarshalJSON marshals this into JSON

func (*FolderEntry) UnmarshalJSON 

func (folder *FolderEntry) UnmarshalJSON(payload []byte) (err error)

UnmarshalJSON decodes JSON

type Folders 

type Folders struct {
	*Client
	// contains filtered or unexported fields
}

Folders module

func (*Folders) Create 

func (module *Folders) Create(ctx context.Context, entry *FolderEntry) (*FolderEntry, error)

Create creates a new folder entry.Name is mandatory, if entry.Parent.ID is not set the root folder is chosen

func (*Folders) Delete 

func (module *Folders) Delete(ctx context.Context, entry *FolderEntry) error

Delete deletes a folder recursively

func (*Folders) FindByID 

func (module *Folders) FindByID(ctx context.Context, folderID string) (*FolderEntry, error)

FindByID retrieves a folder by its id

func (*Folders) FindByName 

func (module *Folders) FindByName(ctx context.Context, name string, parentId string) (*FolderEntry, error)

FindByName retrieves a folder by its name For now, exact match and 1 level (no recursion)

func (*Folders) List 

func (module *Folders) List(ctx context.Context, parentID, marker string, limit int64) (*ListResponse, error)

type ListResponse 

type ListResponse struct {
	Limit      int64         `json:"limit"`
	NextMarker *string       `json:"next_marker"`
	PrevMarker *string       `json:"prev_marker"`
	Entries    []FolderEntry `json:"entries"`
}

type PathCollection 

type PathCollection struct {
	Count  int         `json:"total_count"`
	Offset int         `json:"offset,omitempty"`
	Limit  int         `json:"limit,omitempty"`
	Paths  []PathEntry `json:"entries"`
}

PathCollection represents a collection of PathEntry

type PathEntry 

type PathEntry struct {
	Type       string `json:"type"`
	ID         string `json:"id"`
	Name       string `json:"name"`
	ETag       string `json:"etag"`
	SequenceID string `json:"sequence_id"`
	Checksum   string `json:"sha1,omitempty"`
}

PathEntry represents a Path Entry

type Permissions 

type Permissions struct {
	CanDownload bool `json:"can_download,omitempty"`
	CanPreview  bool `json:"can_preview,omitempty"`
}

Permissions exresses what is allowed on objects

type RequestError 

type RequestError struct {
	Type        string       `json:"type"`
	ID          string       `json:"code"`
	StatusCode  int          `json:"status"`
	Message     string       `json:"message"`
	RequestID   string       `json:"request_id"`
	ContextInfo *ContextInfo `json:"context_info"`
	LocationURL *url.URL     `json:"-"`
	HelpURL     *url.URL     `json:"-"`
}

RequestError represents errors as returned by the BOX.com API

func (RequestError) Error 

func (e RequestError) Error() string

Error gives a string representation of this error Implements interface Error

func (RequestError) Is 

func (e RequestError) Is(target error) bool

Is tells if this error matches the target.

func (RequestError) MarshalJSON 

func (e RequestError) MarshalJSON() ([]byte, error)

MarshalJSON marshals this into JSON

func (*RequestError) UnmarshalJSON 

func (e *RequestError) UnmarshalJSON(payload []byte) (err error)

UnmarshalJSON decodes JSON 

type SharedLink struct {
	URL               *url.URL    `json:"-"`
	DownloadURL       *url.URL    `json:"-"`
	VanityURL         *url.URL    `json:"-"`
	EffectiveAccess   string      `json:"effective_access"`
	IsPasswordEnabled bool        `json:"is_password_enabled"`
	UnsharedAt        *time.Time  `json:"-"`
	DownloadCount     int         `json:"download_count"`
	PreviewCount      int         `json:"preview_count"`
	Access            string      `json:"access"`
	Permissions       Permissions `json:"permissions"`
}

SharedLink represents a shared link

func (SharedLink) MarshalJSON 

func (link SharedLink) MarshalJSON() ([]byte, error)

MarshalJSON marshals this into JSON

func (*SharedLink) UnmarshalJSON 

func (link *SharedLink) UnmarshalJSON(payload []byte) (err error)

UnmarshalJSON decodes JSON

type SharedLinkOptions 

type SharedLinkOptions struct {
	Access      string      `json:"access"`
	UnsharedAt  *time.Time  `json:"-"`
	Password    string      `json:"password,omitempty"`
	Permissions Permissions `json:"permissions,omitempty"`
}

SharedLinkOptions contains the shared link options

func (SharedLinkOptions) MarshalJSON 

func (slo SharedLinkOptions) MarshalJSON() ([]byte, error)

MarshalJSON marshals this into JSON 

type SharedLinks struct {
	*Client
	// contains filtered or unexported fields
}

SharedLinks module

func (*SharedLinks) Create 

func (module *SharedLinks) Create(ctx context.Context, entry *FileEntry, options *SharedLinkOptions) (*SharedLink, error)

Create creates a shared link for a given File entry

type StillProcessingError 

type StillProcessingError struct{}

func (StillProcessingError) Error 

func (err StillProcessingError) Error() string

type Token 

type Token struct {
	TokenType    string    `json:"token_type"`
	AccessToken  string    `json:"access_token"`
	ExpiresOn    time.Time `json:"expires_on"`
	RestrictedTo []string  `json:"restricted_to"`
}

Token is the token used to send requests to Box.com

func TokenFromContext 

func TokenFromContext(ctx context.Context) *Token

TokenFromContext retrieves a token from the given context If no token was stored in the context, nil is returned

func (Token) IsValid 

func (token Token) IsValid() bool

IsValid tells if the token is valid and not expired

func (*Token) ToContext 

func (token *Token) ToContext(parent context.Context) context.Context

ToContext stores this token to the given context If the token is not set, the context is untouched

func (*Token) UnmarshalJSON 

func (token *Token) UnmarshalJSON(payload []byte) (err error)

UnmarshalJSON decodes JSON

type UploadOptions 

type UploadOptions struct {
	Parent   *PathEntry
	FileId   string
	Filename string
	Content  *request.Content
	Payload  interface{}
}

UploadOptions contains the options for uploading data

type UploadSession 

type UploadSession struct {
	Id             string                 `json:"id"`
	ExpiresAt      string                 `json:"session_expires_at"`
	PartSize       int64                  `json:"part_size"`
	TotalParts     int32                  `json:"total_parts"`
	ProcessedParts int32                  `json:"num_parts_processed"`
	Endpoints      UploadSessionEndpoints `json:"session_endpoints"`
	FilePath       string                 `json:"-"`
	FileSize       int64                  `json:"-"`
	Client         *Client                `json:"-"`
	Parts          []UploadSessionPart    `json:"-"`
}

func (*UploadSession) Abort 

func (session *UploadSession) Abort(ctx context.Context) error

func (*UploadSession) Commit 

func (session *UploadSession) Commit(ctx context.Context) (*FileCollection, error)

func (*UploadSession) ListParts 

func (session *UploadSession) ListParts(ctx context.Context) ([]UploadSessionPart, error)

func (*UploadSession) RefreshSessionStatus 

func (session *UploadSession) RefreshSessionStatus(ctx context.Context) (*UploadSession, error)

func (*UploadSession) UploadPart 

func (session *UploadSession) UploadPart(ctx context.Context, data []byte, offset int) (*UploadSessionPart, error)

type UploadSessionEndpoints 

type UploadSessionEndpoints struct {
	UploadPart string `json:"upload_part"`
	Commit     string `json:"commit"`
	Abort      string `json:"abort"`
	Status     string `json:"status"`
	ListParts  string `json:"list_parts"`
	LogEvent   string `json:"log_event"`
}

type UploadSessionOptions 

type UploadSessionOptions struct {
	FolderId string `json:"folder_id"`
	FileSize int64  `json:"file_size"`
	FileName string `json:"file_name"`
	FilePath string `json:"-"`
}

type UploadSessionPart 

type UploadSessionPart struct {
	PartId string `json:"part_id"`
	Offset int64  `json:"offset"`
	Size   int64  `json:"size"`
	Sha1   string `json:"sha1"`
}

type UserEntry 

type UserEntry struct {
	Type  string `json:"type"`
	ID    string `json:"id"`
	Name  string `json:"name"`
	Login string `json:"login"`
}

UserEntry represents a User in a FileEntry

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.