/**
* gdata_tasks_service_insert_task:
* @self: a #GDataTasksService
* @task: the #GDataTasksTask to insert
* @tasklist: #GDataTasksTasklist to insert into
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @error: (allow-none): a #GError, or %NULL
*
* Inserts @task by uploading it to the online tasks service into tasklist @tasklist. It is safe to unref @tasklist after function returns.
*
* For more details, see gdata_service_insert_entry().
*
* Return value: (transfer full): an updated #GDataTasksTask, or %NULL; unref with g_object_unref()
*
* Since: 0.15.0
*/
GDataTasksTask *
gdata_tasks_service_insert_task (GDataTasksService *self, GDataTasksTask *task, GDataTasksTasklist *tasklist, GCancellable *cancellable, GError **error)
{
gchar *request_uri;
GDataEntry *entry;
g_return_val_if_fail (GDATA_IS_TASKS_SERVICE (self), NULL);
g_return_val_if_fail (GDATA_IS_TASKS_TASK (task), NULL);
g_return_val_if_fail (GDATA_IS_TASKS_TASKLIST (tasklist), NULL);
g_return_val_if_fail (gdata_entry_get_id (GDATA_ENTRY (tasklist)) != NULL, NULL);
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
request_uri = g_strconcat (_gdata_service_get_scheme (), "://www.googleapis.com/tasks/v1/lists/", gdata_entry_get_id (GDATA_ENTRY (tasklist)), "/tasks", NULL);
entry = gdata_service_insert_entry (GDATA_SERVICE (self), get_tasks_authorization_domain (), request_uri, GDATA_ENTRY (task), cancellable, error);
g_free (request_uri);
return GDATA_TASKS_TASK (entry);
}
static gboolean
account_miner_job_process_entry (GomAccountMinerJob *job,
GDataDocumentsEntry *doc_entry,
GError **error)
{
GDataEntry *entry = GDATA_ENTRY (doc_entry);
gchar *resource = NULL;
gchar *date, *identifier;
const gchar *class = NULL;
const gchar *mimetype_override = NULL;
gboolean mtime_changed, resource_exists;
gint64 new_mtime;
GList *authors, *l, *parents = NULL;
GDataAuthor *author;
GDataLink *parent;
GDataLink *alternate;
const gchar *alternate_uri;
GList *categories;
GDataCategory *category;
gboolean starred = FALSE;
GDataFeed *access_rules = NULL;
if (GDATA_IS_DOCUMENTS_FOLDER (doc_entry))
{
GDataLink *link;
link = gdata_entry_look_up_link (entry, GDATA_LINK_SELF);
identifier = g_strdup_printf ("gd:collection:%s", gdata_link_get_uri (link));
}
else
identifier = g_strdup (gdata_entry_get_id (entry));
/* remove from the list of the previous resources */
g_hash_table_remove (job->previous_resources, identifier);
if (GDATA_IS_DOCUMENTS_PRESENTATION (doc_entry))
class = "nfo:Presentation";
else if (GDATA_IS_DOCUMENTS_SPREADSHEET (doc_entry))
/**
* gdata_calendar_service_insert_calendar_event_async:
* @self: a #GDataCalendarService
* @calendar: the #GDataCalendarCalendar to insert the event into
* @event: the #GDataCalendarEvent to insert
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @callback: a #GAsyncReadyCallback to call when insertion is finished
* @user_data: (closure): data to pass to the @callback function
*
* Inserts @event by uploading it to the online calendar service, adding it to
* the specified @calendar. @self and @event are both reffed when this function
* is called, so can safely be unreffed after this function returns.
*
* @callback should call gdata_service_insert_entry_finish() to obtain a
* #GDataCalendarEvent representing the inserted event and to check for possible
* errors.
*
* For more details, see gdata_calendar_service_insert_event(), which is the
* synchronous version of this function, and gdata_service_insert_entry_async(),
* which is the base asynchronous insertion function.
*
* Since: 0.17.2
*/
void
gdata_calendar_service_insert_calendar_event_async (GDataCalendarService *self,
GDataCalendarCalendar *calendar,
GDataCalendarEvent *event,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
gchar *uri;
g_return_if_fail (GDATA_IS_CALENDAR_SERVICE (self));
g_return_if_fail (GDATA_IS_CALENDAR_EVENT (event));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
uri = build_events_uri (calendar);
gdata_service_insert_entry_async (GDATA_SERVICE (self),
get_calendar_authorization_domain (),
uri, GDATA_ENTRY (event), cancellable,
callback, user_data);
g_free (uri);
}
void
open_in_web_browser_activate_cb (GtkAction *action, TotemYouTubePlugin *self)
{
GtkTreeSelection *selection;
GtkTreeModel *model;
GList *paths, *path;
selection = gtk_tree_view_get_selection (self->tree_view[self->current_tree_view]);
paths = gtk_tree_selection_get_selected_rows (selection, &model);
for (path = paths; path != NULL; path = path->next) {
GtkTreeIter iter;
GDataYouTubeVideo *video;
GDataLink *link;
GError *error = NULL;
if (gtk_tree_model_get_iter (model, &iter, (GtkTreePath*) (path->data)) == FALSE)
continue;
/* Get the HTML page for the video; its <link rel="alternate" ... /> */
gtk_tree_model_get (model, &iter, 3, &video, -1);
link = gdata_entry_look_up_link (GDATA_ENTRY (video), GDATA_LINK_ALTERNATE);
g_object_unref (video);
/* Display the page */
if (gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (self->bvw)), gdata_link_get_uri (link), GDK_CURRENT_TIME, &error) == FALSE) {
GtkWindow *window = totem_get_main_window (self->totem);
totem_interface_error (_("Error Opening Video in Web Browser"), error->message, window);
g_object_unref (window);
g_error_free (error);
}
}
g_list_foreach (paths, (GFunc) gtk_tree_path_free, NULL);
g_list_free (paths);
}
static gboolean
parse_json (GDataParsable *parsable, JsonReader *reader, gpointer user_data, GError **error)
{
gboolean success = TRUE;
gchar *next_uri = NULL;
/* JSON format: https://developers.google.com/drive/v2/reference/files/list */
if (gdata_parser_string_from_json_member (reader, "nextLink", P_DEFAULT, &next_uri, &success, error) == TRUE) {
if (success && next_uri != NULL && next_uri[0] != '\0') {
GDataLink *_link;
_link = gdata_link_new (next_uri, "http://www.iana.org/assignments/relation/next");
_gdata_feed_add_link (GDATA_FEED (parsable), _link);
g_object_unref (_link);
}
g_free (next_uri);
return success;
} else if (g_strcmp0 (json_reader_get_member_name (reader), "items") == 0) {
guint i, elements;
if (json_reader_is_array (reader) == FALSE) {
g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR,
/* Translators: the parameter is an error message */
_("Error parsing JSON: %s"),
"JSON node ‘items’ is not an array.");
return FALSE;
}
/* Loop through the elements array. */
for (i = 0, elements = (guint) json_reader_count_elements (reader); success && i < elements; i++) {
GDataEntry *entry = NULL;
GError *child_error = NULL;
GType entry_type = G_TYPE_INVALID;
gchar *kind = NULL;
gchar *mime_type = NULL;
json_reader_read_element (reader, i);
if (json_reader_is_object (reader) == FALSE) {
g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR,
/* Translators: the parameter is an error message */
_("Error parsing JSON: %s"),
"JSON node inside ‘items’ is not an object");
success = FALSE;
goto continuation;
}
get_kind_and_mime_type (reader, &kind, &mime_type, &child_error);
if (child_error != NULL) {
g_propagate_error (error, child_error);
success = FALSE;
goto continuation;
}
if (g_strcmp0 (kind, "drive#file") == 0) {
entry_type = gdata_documents_utils_get_type_from_content_type (mime_type);
} else {
g_warning ("%s files are not handled yet", kind);
}
if (entry_type == G_TYPE_INVALID)
goto continuation;
entry = GDATA_ENTRY (_gdata_parsable_new_from_json_node (entry_type, reader, NULL, error));
/* Call the progress callback in the main thread */
_gdata_feed_call_progress_callback (GDATA_FEED (parsable), user_data, entry);
_gdata_feed_add_entry (GDATA_FEED (parsable), entry);
continuation:
g_clear_object (&entry);
g_free (kind);
g_free (mime_type);
json_reader_end_element (reader);
}
return success;
}
return GDATA_PARSABLE_CLASS (gdata_documents_feed_parent_class)->parse_json (parsable, reader, user_data, error);
}
/**
* gdata_tasks_service_update_tasklist_async:
* @self: a #GDataTasksService
* @tasklist: #GDataTasksTasklist to update
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @callback: a #GAsyncReadyCallback to call when insertion is finished
* @user_data: (closure): data to pass to the @callback function
*
* Updates @tasklist from online tasks service. @self and @tasklist are both reffed when this function is called, so can safely be
* unreffed after this function returns.
*
* @callback should call gdata_service_update_entry_finish() to obtain a #GDataTasksTasklist representing the updated task and to check for possible
* errors.
*
* For more details, see gdata_tasks_service_update_tasklist(), which is the synchronous version of this function, and
* gdata_service_update_entry_async(), which is the base asynchronous insertion function.
*
* Since: 0.15.0
*/
void
gdata_tasks_service_update_tasklist_async (GDataTasksService *self, GDataTasksTasklist *tasklist, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
g_return_if_fail (GDATA_IS_TASKS_SERVICE (self));
g_return_if_fail (GDATA_IS_TASKS_TASKLIST (tasklist));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
gdata_service_update_entry_async (GDATA_SERVICE (self), get_tasks_authorization_domain (), GDATA_ENTRY (tasklist), cancellable,
callback, user_data);
}
/**
* gdata_tasks_service_update_tasklist:
* @self: a #GDataTasksService
* @tasklist: the #GDataTasksTasklist to update
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @error: (allow-none): a #GError, or %NULL
*
* Update @tasklist in online tasks service.
*
* For more details, see gdata_service_update_entry().
*
* Return value: (transfer full): an updated #GDataTasksTasklist, or %NULL; unref with g_object_unref()
*
* Since: 0.15.0
*/
GDataTasksTasklist *
gdata_tasks_service_update_tasklist (GDataTasksService *self, GDataTasksTasklist *tasklist, GCancellable *cancellable, GError **error)
{
g_return_val_if_fail (GDATA_IS_TASKS_SERVICE (self), NULL);
g_return_val_if_fail (GDATA_IS_TASKS_TASKLIST (tasklist), NULL);
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
return GDATA_TASKS_TASKLIST (gdata_service_update_entry (GDATA_SERVICE (self), get_tasks_authorization_domain (), GDATA_ENTRY (tasklist), cancellable, error));
}
/**
* gdata_tasks_service_delete_task:
* @self: a #GDataTasksService
* @task: the #GDataTasksTask to delete
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @error: (allow-none): a #GError, or %NULL
*
* Delete @task from online tasks service.
*
* For more details, see gdata_service_delete_entry().
*
* Return value: %TRUE on success, %FALSE otherwise
*
* Since: 0.15.0
*/
gboolean
gdata_tasks_service_delete_task (GDataTasksService *self, GDataTasksTask *task, GCancellable *cancellable, GError **error)
{
g_return_val_if_fail (GDATA_IS_TASKS_SERVICE (self), FALSE);
g_return_val_if_fail (GDATA_IS_TASKS_TASK (task), FALSE);
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
return gdata_service_delete_entry (GDATA_SERVICE (self), get_tasks_authorization_domain (), GDATA_ENTRY (task), cancellable, error);
}
/**
* gdata_tasks_service_insert_tasklist_async:
* @self: a #GDataTasksService
* @tasklist: #GDataTasksTasklist to insert
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @callback: a #GAsyncReadyCallback to call when insertion is finished
* @user_data: (closure): data to pass to the @callback function
*
* Inserts @tasklist by uploading it to the online tasks service. @self and @tasklist are both reffed when this function is called, so can safely be
* unreffed after this function returns.
*
* @callback should call gdata_service_insert_entry_finish() to obtain a #GDataTasksTasklist representing the inserted tasklist and to check for possible
* errors.
*
* For more details, see gdata_tasks_service_insert_tasklist(), which is the synchronous version of this function, and
* gdata_service_insert_entry_async(), which is the base asynchronous insertion function.
*
* Since: 0.15.0
*/
void
gdata_tasks_service_insert_tasklist_async (GDataTasksService *self, GDataTasksTasklist *tasklist, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
gchar *request_uri;
g_return_if_fail (GDATA_IS_TASKS_SERVICE (self));
g_return_if_fail (GDATA_IS_TASKS_TASKLIST (tasklist));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
request_uri = g_strconcat (_gdata_service_get_scheme (), "://www.googleapis.com/tasks/v1/users/@me/lists", NULL);
gdata_service_insert_entry_async (GDATA_SERVICE (self), get_tasks_authorization_domain (), request_uri, GDATA_ENTRY (tasklist), cancellable,
callback, user_data);
g_free (request_uri);
}
/**
* tmp_picasaweb_upload_async:
*
* Temporary solution to provide asynchronous uploading and stop
* blocking the UI until gdata_picasaweb_service_upload_file_async()
* becomes available (bgo #600262). This method does the synchronous
* file upload, but is run asynchronously via
* g_simple_async_result_run_in_thread().
*
* This sets up a minimal #GDataPicasaWebFile entry, using the
* basename of the filepath for the file's title (which is not the
* caption, but might be something we would consider doing). The
* image file and the minimal entry are then uploaded to PicasaWeb's
* default album of "Drop Box". In the future, we might consider
* adding an Album Chooser to the Preferences/login window, but only
* if there's demand.
**/
static void
tmp_picasaweb_upload_async (GSimpleAsyncResult *result, GObject *source_object, GCancellable *cancellable)
{
GDataPicasaWebFile *new_file = NULL;
XviewerPostasaPlugin *plugin = XVIEWER_POSTASA_PLUGIN (source_object);
GDataPicasaWebService *service = plugin->priv->service;
GDataPicasaWebFile *file_entry;
PicasaWebUploadFileAsyncData *data;
#ifdef HAVE_LIBGDATA_0_8
GDataUploadStream *upload_stream;
GFileInputStream *in_stream;
GFileInfo *file_info;
#endif
gchar *filename;
GError *error = NULL;
data = (PicasaWebUploadFileAsyncData*)g_async_result_get_user_data (G_ASYNC_RESULT (result));
/* get filename to set image title */
file_entry = gdata_picasaweb_file_new (NULL);
filename = g_file_get_basename (data->imgfile);
gdata_entry_set_title (GDATA_ENTRY (file_entry), filename);
g_free (filename);
#ifdef HAVE_LIBGDATA_0_8
file_info = g_file_query_info (data->imgfile,
G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME ","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE, cancellable,
&error);
if (file_info == NULL)
goto got_err;
upload_stream = gdata_picasaweb_service_upload_file (service,
NULL /* Upload to Dropbox */, file_entry,
g_file_info_get_display_name (file_info),
g_file_info_get_content_type (file_info),
cancellable, &error);
g_object_unref (file_info);
if (upload_stream == NULL)
goto got_err;
in_stream = g_file_read (data->imgfile, cancellable, &error);
if (in_stream == NULL) {
g_object_unref (upload_stream);
goto got_err;
}
if (g_output_stream_splice (G_OUTPUT_STREAM (upload_stream),
G_INPUT_STREAM (in_stream),
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
cancellable, &error) == -1)
{
g_object_unref (upload_stream);
g_object_unref (in_stream);
goto got_err;
}
new_file = gdata_picasaweb_service_finish_file_upload (service,
upload_stream,
&error);
g_object_unref (upload_stream);
g_object_unref (in_stream);
got_err:
/* Jump here if any GIO/GData call doesn't return successfully.
* Error handling happens below. */
#else
/* libgdata-0.6 */
new_file = gdata_picasaweb_service_upload_file (service,
NULL /* Uploading to Drop Box */,
file_entry, data->imgfile,
cancellable, &error);
#endif
g_object_unref (file_entry);
if (new_file == NULL || error) {
if (g_cancellable_is_cancelled (cancellable) == FALSE) {
g_simple_async_result_set_from_error (result, error);
}
/* Clear errors always as cancelling creates errors too */
g_clear_error (&error);
} else {
g_simple_async_result_set_op_res_gboolean (result, TRUE);
}
if (new_file != NULL)
g_object_unref (new_file);
}
/**
* gdata_contacts_service_insert_group_async:
* @self: a #GDataContactsService
* @group: the #GDataContactsGroup to insert
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @callback: a #GAsyncReadyCallback to call when insertion is finished
* @user_data: (closure): data to pass to the @callback function
*
* Inserts a new contact group described by @group. The user must be authenticated to use this function. @self and @group are both reffed when this
* function is called, so can safely be unreffed after this function returns.
*
* @callback should call gdata_service_insert_entry_finish() to obtain a #GDataContactsGroup representing the inserted group and to check for possible
* errors.
*
* For more details, see gdata_contacts_service_insert_group(), which is the synchronous version of this function, and
* gdata_service_insert_entry_async(), which is the base asynchronous insertion function.
*
* Since: 0.7.0
**/
void
gdata_contacts_service_insert_group_async (GDataContactsService *self, GDataContactsGroup *group, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
gchar *request_uri;
g_return_if_fail (GDATA_IS_CONTACTS_SERVICE (self));
g_return_if_fail (GDATA_IS_CONTACTS_GROUP (group));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
request_uri = g_strconcat (_gdata_service_get_scheme (), "://www.google.com/m8/feeds/groups/default/full", NULL);
gdata_service_insert_entry_async (GDATA_SERVICE (self), get_contacts_authorization_domain (), request_uri, GDATA_ENTRY (group), cancellable,
callback, user_data);
g_free (request_uri);
}
/**
* gdata_contacts_service_insert_contact:
* @self: a #GDataContactsService
* @contact: the #GDataContactsContact to insert
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @error: a #GError, or %NULL
*
* Inserts @contact by uploading it to the online contacts service.
*
* For more details, see gdata_service_insert_entry().
*
* Return value: (transfer full): an updated #GDataContactsContact, or %NULL; unref with g_object_unref()
*
* Since: 0.2.0
**/
GDataContactsContact *
gdata_contacts_service_insert_contact (GDataContactsService *self, GDataContactsContact *contact, GCancellable *cancellable, GError **error)
{
gchar *uri;
GDataEntry *entry;
g_return_val_if_fail (GDATA_IS_CONTACTS_SERVICE (self), NULL);
g_return_val_if_fail (GDATA_IS_CONTACTS_CONTACT (contact), NULL);
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
uri = g_strconcat (_gdata_service_get_scheme (), "://www.google.com/m8/feeds/contacts/default/full", NULL);
entry = gdata_service_insert_entry (GDATA_SERVICE (self), get_contacts_authorization_domain (), uri, GDATA_ENTRY (contact), cancellable,
error);
g_free (uri);
return GDATA_CONTACTS_CONTACT (entry);
}
static void destroy_entries(gpointer data, gpointer user_data)
{
GDataEntry *entry = GDATA_ENTRY(data);
g_object_unref(G_OBJECT(entry));
}
/**
* gdata_calendar_service_insert_event:
* @self: a #GDataCalendarService
* @event: the #GDataCalendarEvent to insert
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @error: a #GError, or %NULL
*
* Inserts @event by uploading it to the online calendar service.
*
* For more details, see gdata_service_insert_entry().
*
* Return value: (transfer full): an updated #GDataCalendarEvent, or %NULL; unref with g_object_unref()
*
* Since: 0.2.0
* Deprecated: 0.17.2: Use gdata_calendar_service_insert_calendar_event()
* instead to be able to specify the calendar to add the event to; otherwise
* the default calendar will be used.
*/
GDataCalendarEvent *
gdata_calendar_service_insert_event (GDataCalendarService *self, GDataCalendarEvent *event, GCancellable *cancellable, GError **error)
{
gchar *uri;
GDataEntry *entry;
g_return_val_if_fail (GDATA_IS_CALENDAR_SERVICE (self), NULL);
g_return_val_if_fail (GDATA_IS_CALENDAR_EVENT (event), NULL);
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
uri = build_events_uri (NULL);
entry = gdata_service_insert_entry (GDATA_SERVICE (self), get_calendar_authorization_domain (), uri, GDATA_ENTRY (event), cancellable, error);
g_free (uri);
return GDATA_CALENDAR_EVENT (entry);
}
/**
* gdata_access_handler_insert_rule:
* @self: a #GDataAccessHandler
* @service: a #GDataService
* @rule: the #GDataAccessRule to insert
* @cancellable: optional #GCancellable object, or %NULL
* @error: a #GError, or %NULL
*
* Inserts @rule in the access control list of the #GDataAccessHandler.
*
* The service will return an updated version of the rule, which is the return value of this function on success.
*
* If @cancellable is not %NULL, then the operation can be cancelled by triggering the @cancellable object from another thread.
* If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
*
* If the rule is marked as already having been inserted a %GDATA_SERVICE_ERROR_ENTRY_ALREADY_INSERTED error will be returned immediately
* (there will be no network requests).
*
* If there is an error inserting the rule, a %GDATA_SERVICE_ERROR_WITH_INSERTION error will be returned.
*
* Return value: an updated #GDataAccessRule, or %NULL
*
* Since: 0.3.0
**/
GDataAccessRule *
gdata_access_handler_insert_rule (GDataAccessHandler *self, GDataService *service, GDataAccessRule *rule, GCancellable *cancellable, GError **error)
{
GDataServiceClass *klass;
GDataAccessRule *updated_rule;
GDataLink *link;
SoupMessage *message;
gchar *upload_data;
guint status;
g_return_val_if_fail (GDATA_IS_ENTRY (self), NULL);
g_return_val_if_fail (GDATA_IS_SERVICE (service), NULL);
g_return_val_if_fail (GDATA_IS_ACCESS_RULE (rule), NULL);
if (gdata_entry_is_inserted (GDATA_ENTRY (rule)) == TRUE) {
g_set_error_literal (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_ENTRY_ALREADY_INSERTED,
_("The rule has already been inserted."));
return NULL;
}
/* Get the ACL URI */
link = gdata_entry_look_up_link (GDATA_ENTRY (self), "http://schemas.google.com/acl/2007#accessControlList");
g_assert (link != NULL);
message = soup_message_new (SOUP_METHOD_POST, link->href);
/* Make sure subclasses set their headers */
klass = GDATA_SERVICE_GET_CLASS (service);
if (klass->append_query_headers != NULL)
klass->append_query_headers (service, message);
/* Append the data */
upload_data = gdata_entry_get_xml (GDATA_ENTRY (rule));
soup_message_set_request (message, "application/atom+xml", SOUP_MEMORY_TAKE, upload_data, strlen (upload_data));
/* Send the message */
status = _gdata_service_send_message (service, message, error);
if (status == SOUP_STATUS_NONE) {
g_object_unref (message);
return NULL;
}
/* Check for cancellation */
if (g_cancellable_set_error_if_cancelled (cancellable, error) == TRUE) {
g_object_unref (message);
return NULL;
}
if (status != 201) {
/* Error */
g_assert (klass->parse_error_response != NULL);
klass->parse_error_response (service, GDATA_SERVICE_ERROR_WITH_INSERTION, status, message->reason_phrase, message->response_body->data,
message->response_body->length, error);
g_object_unref (message);
return NULL;
}
/* Build the updated entry */
g_assert (message->response_body->data != NULL);
/* Parse the XML; create and return a new GDataEntry of the same type as @entry */
updated_rule = GDATA_ACCESS_RULE (_gdata_entry_new_from_xml (G_OBJECT_TYPE (rule), message->response_body->data,
message->response_body->length, error));
g_object_unref (message);
return updated_rule;
}
gint
main (void)
{
GDataDocumentsFeed *feed = NULL;
GDataDocumentsQuery *query = NULL;
GDataDocumentsService *service = NULL;
GError *error = NULL;
GList *accounts = NULL;
GList *entries;
GList *l;
GoaClient *client = NULL;
client = goa_client_new_sync (NULL, &error);
if (error != NULL) {
g_warning ("%s", error->message);
g_error_free (error);
goto out;
}
accounts = goa_client_get_accounts (client);
for (l = accounts; l != NULL; l = l->next) {
GoaAccount *account;
GoaObject *object = GOA_OBJECT (l->data);
const gchar *provider_type;
account = goa_object_peek_account (object);
provider_type = goa_account_get_provider_type (account);
if (g_strcmp0 (provider_type, "google") == 0) {
GDataGoaAuthorizer *authorizer;
authorizer = gdata_goa_authorizer_new (object);
service = gdata_documents_service_new (GDATA_AUTHORIZER (authorizer));
g_object_unref (authorizer);
}
}
if (service == NULL) {
g_warning ("Account not found");
goto out;
}
query = gdata_documents_query_new_with_limits (NULL, 1, 10);
gdata_documents_query_set_show_folders (query, TRUE);
while (TRUE) {
feed = gdata_documents_service_query_documents (service, query, NULL, NULL, NULL, &error);
if (error != NULL) {
g_warning ("%s", error->message);
g_error_free (error);
goto out;
}
entries = gdata_feed_get_entries (GDATA_FEED (feed));
if (entries == NULL) {
goto out;
}
for (l = entries; l != NULL; l = l->next) {
GDataEntry *entry = GDATA_ENTRY (l->data);
const gchar *title;
title = gdata_entry_get_title (entry);
g_message ("%s", title);
}
gdata_query_next_page (GDATA_QUERY (query));
g_object_unref (feed);
}
out:
g_clear_object (&feed);
g_clear_object (&query);
g_clear_object (&service);
g_clear_object (&client);
g_list_free_full (accounts, g_object_unref);
return 0;
}