GDataDocumentsService

GDataDocumentsService — GData Documents service object

Stability Level

Unstable, unless otherwise indicated

Synopsis

#include <gdata/services/documents/gdata-documents-service.h>

                    GDataDocumentsService;
                    GDataDocumentsServiceClass;
enum                GDataDocumentsServiceError;
GDataDocumentsService * gdata_documents_service_new     (GDataAuthorizer *authorizer);
GDataAuthorizationDomain * gdata_documents_service_get_primary_authorization_domain
                                                        (void);
GDataAuthorizationDomain * gdata_documents_service_get_spreadsheet_authorization_domain
                                                        (void);
GDataDocumentsFeed * gdata_documents_service_query_documents
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsQuery *query,
                                                         GCancellable *cancellable,
                                                         GDataQueryProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
void                gdata_documents_service_query_documents_async
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsQuery *query,
                                                         GCancellable *cancellable,
                                                         GDataQueryProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GDataUploadStream * gdata_documents_service_upload_document
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsDocument *document,
                                                         const gchar *slug,
                                                         const gchar *content_type,
                                                         GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);
GDataUploadStream * gdata_documents_service_update_document
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsDocument *document,
                                                         const gchar *slug,
                                                         const gchar *content_type,
                                                         GCancellable *cancellable,
                                                         GError **error);
GDataDocumentsDocument * gdata_documents_service_finish_upload
                                                        (GDataDocumentsService *self,
                                                         GDataUploadStream *upload_stream,
                                                         GError **error);
GDataDocumentsEntry * gdata_documents_service_add_entry_to_folder
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsEntry *entry,
                                                         GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gdata_documents_service_add_entry_to_folder_async
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsEntry *entry,
                                                         GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GDataDocumentsEntry * gdata_documents_service_add_entry_to_folder_finish
                                                        (GDataDocumentsService *self,
                                                         GAsyncResult *async_result,
                                                         GError **error);
GDataDocumentsEntry * gdata_documents_service_remove_entry_from_folder
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsEntry *entry,
                                                         GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gdata_documents_service_remove_entry_from_folder_async
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsEntry *entry,
                                                         GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GDataDocumentsEntry * gdata_documents_service_remove_entry_from_folder_finish
                                                        (GDataDocumentsService *self,
                                                         GAsyncResult *async_result,
                                                         GError **error);
gchar *             gdata_documents_service_get_upload_uri
                                                        (GDataDocumentsFolder *folder);

Object Hierarchy

  GObject
   +----GDataService
         +----GDataDocumentsService
  GEnum
   +----GDataDocumentsServiceError

Implemented Interfaces

GDataDocumentsService implements GDataBatchable.

Description

GDataDocumentsService is a subclass of GDataService for communicating with the GData API of Google Documents. It supports querying for, inserting, editing and deleting documents, as well as a folder hierarchy.

For more details of Google Documents' GData API, see the online documentation.

Fore more details about the spreadsheet downloads handling, see the online explanation about the problem.

Example 22. Uploading a Document from Disk

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
GDataDocumentsService *service;
GDataDocumentsDocument *document, *uploaded_document;
GFile *document_file;
GDataDocumentsFolder *destination_folder;
GFileInfo *file_info;
const gchar *slug, *content_type;
GFileInputStream *file_stream;
GDataUploadStream *upload_stream;
GError *error = NULL;

/* Create a service */
service = create_documents_service ();

/* Get the document file to upload and the folder to upload it into */
document_file = g_file_new_for_path ("document.odt");
destination_folder = query_user_for_destination_folder (service);

/* Get the file's display name and content type */
file_info = g_file_query_info (document_file, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
                               G_FILE_QUERY_INFO_NONE, NULL, &error);

if (error != NULL) {
    g_error ("Error getting document file information: %s", error->message);
    g_error_free (error);
    g_object_unref (destination_folder);
    g_object_unref (document_file);
    g_object_unref (service);
    return;
}

slug = g_file_info_get_display_name (file_info);
content_type = g_file_info_get_content_type (file_info);

/* Get an input stream for the file */
file_stream = g_file_read (document_file, NULL, &error);

g_object_unref (document_file);

if (error != NULL) {
    g_error ("Error getting document file stream: %s", error->message);
    g_error_free (error);
    g_object_unref (file_info);
    g_object_unref (destination_folder);
    g_object_unref (service);
    return;
}

/* Create the document metadata to upload */
document = gdata_documents_text_new (NULL);
gdata_entry_set_title (GDATA_ENTRY (document), "Document Title");

/* Get an upload stream for the document */
upload_stream = gdata_documents_service_upload_document (service, document, slug, content_type, destination_folder, NULL, &error);

g_object_unref (document);
g_object_unref (file_info);
g_object_unref (destination_folder);

if (error != NULL) {
    g_error ("Error getting upload stream: %s", error->message);
    g_error_free (error);
    g_object_unref (file_stream);
    g_object_unref (service);
    return;
}

/* Upload the document. This is a blocking operation, and should normally be done asynchronously. */
g_output_stream_splice (G_OUTPUT_STREAM (upload_stream), G_INPUT_STREAM (file_stream),
                        G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, &error);

g_object_unref (file_stream);

if (error != NULL) {
    g_error ("Error splicing streams: %s", error->message);
    g_error_free (error);
    g_object_unref (upload_stream);
    g_object_unref (service);
    return;
}

/* Finish off the upload by parsing the returned updated document metadata entry */
uploaded_document = gdata_documents_service_finish_upload (service, upload_stream, &error);

g_object_unref (upload_stream);
g_object_unref (service);

if (error != NULL) {
    g_error ("Error uploading document: %s", error->message);
    g_error_free (error);
    return;
}

/* Do something with the uploaded document */

g_object_unref (uploaded_document);


The Documents service can be manipulated using batch operations, too. See the online documentation on batch operations for more information.

Example 23. Performing a Batch Operation on Documents

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
GDataDocumentsService *service;
GDataBatchOperation *operation;
GDataFeed *feed;
GDataLink *batch_link;
GList *i;
GError *error = NULL;

/* Create a service */
service = create_documents_service ();

/* Create the batch operation; this requires that we have done a query first so that we can get the batch link */
feed = do_some_query (service);
batch_link = gdata_feed_look_up_link (feed, GDATA_LINK_BATCH);
operation = gdata_batchable_create_operation (GDATA_BATCHABLE (service), gdata_link_get_uri (batch_link));
g_object_unref (feed);

gdata_batch_operation_add_query (operation, presentation_entry_id_to_query, GDATA_TYPE_DOCUMENTS_PRESENTATION,
                                 (GDataBatchOperationCallback) batch_query_cb, user_data);
gdata_batch_operation_add_insertion (operation, new_entry, (GDataBatchOperationCallback) batch_insertion_cb, user_data);
gdata_batch_operation_add_update (operation, old_entry, (GDataBatchOperationCallback) batch_update_cb, user_data);
gdata_batch_operation_add_deletion (operation, entry_to_delete, (GDataBatchOperationCallback) batch_deletion_cb, user_data);

/* Run the batch operation and handle the results in the various callbacks */
gdata_test_batch_operation_run (operation, NULL, &error);

g_object_unref (operation);
g_object_unref (service);

if (error != NULL) {
    g_error ("Error running batch operation: %s", error->message);
    g_error_free (error);
    return;
}

static void
batch_query_cb (guint operation_id, GDataBatchOperationType operation_type, GDataEntry *entry, GError *error, gpointer user_data)
{
    /* operation_type == GDATA_BATCH_OPERATION_QUERY */
    /* Reference and do something with the returned entry. */
}

static void
batch_insertion_cb (guint operation_id, GDataBatchOperationType operation_type, GDataEntry *entry, GError *error, gpointer user_data)
{
    /* operation_type == GDATA_BATCH_OPERATION_INSERTION */
    /* Reference and do something with the returned entry. */
}

static void
batch_update_cb (guint operation_id, GDataBatchOperationType operation_type, GDataEntry *entry, GError *error, gpointer user_data)
{
    /* operation_type == GDATA_BATCH_OPERATION_UPDATE */
    /* Reference and do something with the returned entry. */
}

static void
batch_deletion_cb (guint operation_id, GDataBatchOperationType operation_type, GDataEntry *entry, GError *error, gpointer user_data)
{
    /* operation_type == GDATA_BATCH_OPERATION_DELETION, entry == NULL */
}


Details

GDataDocumentsService

typedef struct _GDataDocumentsService GDataDocumentsService;

All the fields in the GDataDocumentsService structure are private and should never be accessed directly.

Since 0.4.0


GDataDocumentsServiceClass

typedef struct {
} GDataDocumentsServiceClass;

All the fields in the GDataDocumentsServiceClass structure are private and should never be accessed directly.

Since 0.4.0


enum GDataDocumentsServiceError

typedef enum {
	GDATA_DOCUMENTS_SERVICE_ERROR_INVALID_CONTENT_TYPE
} GDataDocumentsServiceError;

Error codes for GDataDocumentsService operations.

GDATA_DOCUMENTS_SERVICE_ERROR_INVALID_CONTENT_TYPE

the content type of a provided file was invalid

Since 0.4.0


gdata_documents_service_new ()

GDataDocumentsService * gdata_documents_service_new     (GDataAuthorizer *authorizer);

Creates a new GDataDocumentsService using the given GDataAuthorizer. If authorizer is NULL, all requests are made as an unauthenticated user.

authorizer :

a GDataAuthorizer to authorize the service's requests, or NULL. [allow-none]

Returns :

a new GDataDocumentsService, or NULL; unref with g_object_unref()

Since 0.9.0


gdata_documents_service_get_primary_authorization_domain ()

GDataAuthorizationDomain * gdata_documents_service_get_primary_authorization_domain
                                                        (void);

The primary GDataAuthorizationDomain for interacting with Google Documents. This will not normally need to be used, as it's used internally by the GDataDocumentsService methods. However, if using the plain GDataService methods to implement custom queries or requests which libgdata does not support natively, then this domain may be needed to authorize the requests.

The domain never changes, and is interned so that pointer comparison can be used to differentiate it from other authorization domains.

Returns :

the service's authorization domain. [transfer none]

Since 0.9.0


gdata_documents_service_get_spreadsheet_authorization_domain ()

GDataAuthorizationDomain * gdata_documents_service_get_spreadsheet_authorization_domain
                                                        (void);

The GDataAuthorizationDomain for interacting with spreadsheet data. This will not normally need to be used, as it's automatically used internally by the GDataDocumentsService methods. However, if using the plain GDataService methods to implement custom queries or requests which libgdata does not support natively, then this domain may be needed to authorize the requests which pertain to the Google Spreadsheets Data API, such as requests to download or upload spreadsheet documents.

The domain never changes, and is interned so that pointer comparison can be used to differentiate it from other authorization domains.

Returns :

the service's authorization domain. [transfer none]

Since 0.9.0


gdata_documents_service_query_documents ()

GDataDocumentsFeed * gdata_documents_service_query_documents
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsQuery *query,
                                                         GCancellable *cancellable,
                                                         GDataQueryProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Queries the service to return a list of documents matching the given query. Note that query has to be a GDataDocumentsQuery, rather than just a GDataQuery, as it uses the folder ID specified in "folder-id".

For more details, see gdata_service_query().

self :

a GDataDocumentsService

query :

a GDataDocumentsQuery with the query parameters, or NULL. [allow-none]

cancellable :

optional GCancellable object, or NULL. [allow-none]

progress_callback :

a GDataQueryProgressCallback to call when an entry is loaded, or NULL. [allow-none][scope call][closure progress_user_data]

progress_user_data :

data to pass to the progress_callback function. [closure]

error :

a GError, or NULL

Returns :

a GDataDocumentsFeed of query results; unref with g_object_unref(). [transfer full]

Since 0.4.0


gdata_documents_service_query_documents_async ()

void                gdata_documents_service_query_documents_async
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsQuery *query,
                                                         GCancellable *cancellable,
                                                         GDataQueryProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Queries the service to return a list of documents matching the given query. self and query are both reffed when this function is called, so can safely be unreffed after this function returns.

For more details, see gdata_documents_service_query_documents(), which is the synchronous version of this function, and gdata_service_query_async(), which is the base asynchronous query function.

self :

a GDataDocumentsService

query :

a GDataDocumentsQuery with the query parameters, or NULL. [allow-none]

cancellable :

optional GCancellable object, or NULL. [allow-none]

progress_callback :

a GDataQueryProgressCallback to call when an entry is loaded, or NULL. [allow-none][closure progress_user_data]

progress_user_data :

data to pass to the progress_callback function. [closure]

callback :

a GAsyncReadyCallback to call when authentication is finished

user_data :

data to pass to the callback function. [closure]

Since 0.4.0


gdata_documents_service_upload_document ()

GDataUploadStream * gdata_documents_service_upload_document
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsDocument *document,
                                                         const gchar *slug,
                                                         const gchar *content_type,
                                                         GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);

Uploads a document to Google Documents, using the properties from document and the document data written to the resulting GDataUploadStream. If the document data does not need to be provided at the moment, just the metadata, use gdata_service_insert_entry() instead (e.g. in the case of creating a new, empty file to be edited at a later date).

If document is NULL, only the document data will be uploaded. The new document entry will be named using slug, and will have default metadata.

The stream returned by this function should be written to using the standard GOutputStream methods, asychronously or synchronously. Once the stream is closed (using g_output_stream_close()), gdata_documents_service_finish_upload() should be called on it to parse and return the updated GDataDocumentsDocument for the document. This must be done, as document isn't updated in-place.

In order to cancel the upload, a GCancellable passed in to cancellable must be cancelled using g_cancellable_cancel(). Cancelling the individual GOutputStream operations on the GDataUploadStream will not cancel the entire upload; merely the write or close operation in question. See the "cancellable" for more details.

Any upload errors will be thrown by the stream methods, and may come from the GDataServiceError domain.

self :

an authenticated GDataDocumentsService

document :

the GDataDocumentsDocument to insert, or NULL. [allow-none]

slug :

the filename to give to the uploaded document

content_type :

the content type of the uploaded data

folder :

the folder to which the document should be uploaded, or NULL. [allow-none]

cancellable :

a GCancellable for the entire upload stream, or NULL. [allow-none]

error :

a GError, or NULL

Returns :

a GDataUploadStream to write the document data to, or NULL; unref with g_object_unref(). [transfer full]

Since 0.8.0


gdata_documents_service_update_document ()

GDataUploadStream * gdata_documents_service_update_document
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsDocument *document,
                                                         const gchar *slug,
                                                         const gchar *content_type,
                                                         GCancellable *cancellable,
                                                         GError **error);

Update the document using the properties from document and the document data written to the resulting GDataUploadStream. If the document data does not need to be changed, just the metadata, use gdata_service_update_entry() instead.

The stream returned by this function should be written to using the standard GOutputStream methods, asychronously or synchronously. Once the stream is closed (using g_output_stream_close()), gdata_documents_service_finish_upload() should be called on it to parse and return the updated GDataDocumentsDocument for the document. This must be done, as document isn't updated in-place.

In order to cancel the update, a GCancellable passed in to cancellable must be cancelled using g_cancellable_cancel(). Cancelling the individual GOutputStream operations on the GDataUploadStream will not cancel the entire update; merely the write or close operation in question. See the "cancellable" for more details.

Any upload errors will be thrown by the stream methods, and may come from the GDataServiceError domain.

For more information, see gdata_service_update_entry().

self :

a GDataDocumentsService

document :

the GDataDocumentsDocument to update

slug :

the filename to give to the uploaded document

content_type :

the content type of the uploaded data

cancellable :

a GCancellable for the entire upload stream, or NULL. [allow-none]

error :

a GError, or NULL

Returns :

a GDataUploadStream to write the document data to; unref with g_object_unref(). [transfer full]

Since 0.8.0


gdata_documents_service_finish_upload ()

GDataDocumentsDocument * gdata_documents_service_finish_upload
                                                        (GDataDocumentsService *self,
                                                         GDataUploadStream *upload_stream,
                                                         GError **error);

Finish off a document upload or update operation started by gdata_documents_service_upload_document() or gdata_documents_service_update_document(), parsing the result and returning the new or updated GDataDocumentsDocument.

If an error occurred during the upload or update operation, it will have been returned during the operation (e.g. by g_output_stream_splice() or one of the other stream methods). In such a case, NULL will be returned but error will remain unset. error is only set in the case that the server indicates that the operation was successful, but an error is encountered in parsing the result sent by the server.

In the case that no GDataDocumentsDocument was passed (to gdata_documents_service_upload_document() or gdata_documents_service_update_document()) when starting the operation, GDATA_DOCUMENTS_SERVICE_ERROR_INVALID_CONTENT_TYPE will be thrown in error if the content type of the uploaded data could not be mapped to a document type with which to interpret the response from the server.

self :

a GDataDocumentsService

upload_stream :

the GDataUploadStream from the operation

error :

a GError, or NULL

Returns :

the new or updated GDataDocumentsDocument, or NULL; unref with g_object_unref(). [transfer full]

Since 0.8.0


gdata_documents_service_add_entry_to_folder ()

GDataDocumentsEntry * gdata_documents_service_add_entry_to_folder
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsEntry *entry,
                                                         GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);

Add the given entry to the specified folder, and return an updated GDataDocumentsEntry for entry. If the entry is already in another folder, it will be added to the new folder, but will also remain in its other folders. Note that entry can be either a GDataDocumentsDocument or a GDataDocumentsFolder.

Errors from GDataServiceError can be returned for exceptional conditions, as determined by the server.

self :

an authenticated GDataDocumentsService

entry :

the GDataDocumentsEntry to move

folder :

the GDataDocumentsFolder to move entry into

cancellable :

optional GCancellable object, or NULL. [allow-none]

error :

a GError, or NULL

Returns :

an updated GDataDocumentsEntry, or NULL; unref with g_object_unref(). [transfer full]

Since 0.8.0


gdata_documents_service_add_entry_to_folder_async ()

void                gdata_documents_service_add_entry_to_folder_async
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsEntry *entry,
                                                         GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Add the given entry to the specified folder. self, entry and folder are all reffed when this function is called, so can safely be unreffed after this function returns.

For more details, see gdata_documents_service_add_entry_to_folder(), which is the synchronous version of this function.

When the operation is finished, callback will be called. You can then call gdata_documents_service_add_entry_to_folder_finish() to get the results of the operation.

self :

a GDataDocumentsService

entry :

the GDataDocumentsEntry to add to folder

folder :

the GDataDocumentsFolder to add entry to

cancellable :

optional GCancellable object, or NULL. [allow-none]

callback :

a GAsyncReadyCallback to call when the operation is finished, or NULL

user_data :

data to pass to the callback function. [closure]

Since 0.8.0


gdata_documents_service_add_entry_to_folder_finish ()

GDataDocumentsEntry * gdata_documents_service_add_entry_to_folder_finish
                                                        (GDataDocumentsService *self,
                                                         GAsyncResult *async_result,
                                                         GError **error);

Finish an asynchronous operation to add a GDataDocumentsEntry to a folder started with gdata_documents_service_add_entry_to_folder_async().

self :

a GDataDocumentsService

async_result :

a GAsyncResult

error :

a GError, or NULL

Returns :

an updated GDataDocumentsEntry, or NULL; unref with g_object_unref(). [transfer full]

Since 0.8.0


gdata_documents_service_remove_entry_from_folder ()

GDataDocumentsEntry * gdata_documents_service_remove_entry_from_folder
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsEntry *entry,
                                                         GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);

Remove the given entry from folder, and return an updated GDataDocumentsEntry for entry. entry will remain a member of any other folders it's currently in. Note that entry can be either a GDataDocumentsDocument or a GDataDocumentsFolder.

Errors from GDataServiceError can be returned for exceptional conditions, as determined by the server.

self :

a GDataDocumentsService

entry :

the GDataDocumentsEntry to remove

folder :

the GDataDocumentsFolder from which we should remove entry

cancellable :

optional GCancellable object, or NULL. [allow-none]

error :

a GError, or NULL

Returns :

an updated GDataDocumentsEntry, or NULL; unref with g_object_unref(). [transfer full]

Since 0.8.0


gdata_documents_service_remove_entry_from_folder_async ()

void                gdata_documents_service_remove_entry_from_folder_async
                                                        (GDataDocumentsService *self,
                                                         GDataDocumentsEntry *entry,
                                                         GDataDocumentsFolder *folder,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Remove the given entry from the specified folder. self, entry and folder are all reffed when this function is called, so can safely be unreffed after this function returns.

For more details, see gdata_documents_service_remove_entry_from_folder(), which is the synchronous version of this function.

When the operation is finished, callback will be called. You can then call gdata_documents_service_remove_entry_from_folder_finish() to get the results of the operation.

self :

a GDataDocumentsService

entry :

the GDataDocumentsEntry to remove from folder

folder :

the GDataDocumentsFolder to remove entry from

cancellable :

optional GCancellable object, or NULL. [allow-none]

callback :

a GAsyncReadyCallback to call when the operation is finished, or NULL

user_data :

data to pass to the callback function. [closure]

Since 0.8.0


gdata_documents_service_remove_entry_from_folder_finish ()

GDataDocumentsEntry * gdata_documents_service_remove_entry_from_folder_finish
                                                        (GDataDocumentsService *self,
                                                         GAsyncResult *async_result,
                                                         GError **error);

Finish an asynchronous operation to remove a GDataDocumentsEntry from a folder started with gdata_documents_service_remove_entry_from_folder_async().

self :

a GDataDocumentsService

async_result :

a GAsyncResult

error :

a GError, or NULL

Returns :

an updated GDataDocumentsEntry, or NULL; unref with g_object_unref(). [transfer full]

Since 0.8.0


gdata_documents_service_get_upload_uri ()

gchar *             gdata_documents_service_get_upload_uri
                                                        (GDataDocumentsFolder *folder);

Gets the upload URI for documents for the service.

If folder is NULL, the URI will be the one to upload documents to the "root" folder.

folder :

the GDataDocumentsFolder into which to upload the document, or NULL. [allow-none]

Returns :

the URI permitting the upload of documents to folder, or NULL; free with g_free()

Since 0.5.0