GDataDocumentsService

## 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     (const gchar *client_id);
    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.

## Properties

      "spreadsheet-service"      GDataService*         : Read

## 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 21. 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 22. 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     (const gchar *client_id);

Creates a new GDataDocumentsService. The `client_id` must be unique for your application, and as registered with Google.

`client_id` : | your application's client ID
Returns : | a new GDataDocumentsService, or `NULL`; unref with `g_object_unref()`

Since 0.4.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`
`progress_callback` : | a GDataQueryProgressCallback to call when an entry is loaded, or `NULL`. [scope call]
`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`
`progress_callback` : | a GDataQueryProgressCallback to call when an entry is loaded, or `NULL`
`progress_user_data` : | data to pass to the `progress_callback` function
`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`
`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`
`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`
`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`
`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

## Property Details

### The `"spreadsheet-service"` property

      "spreadsheet-service"      GDataService*         : Read

Another service for spreadsheets.