path: root/gdata/gdata-commentable.c

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/*
 * GData Client
 * Copyright (C) Philip Withnall 2008–2010 <philip@tecnocode.co.uk>
 * Copyright (C) Richard Schwarting 2010 <aquarichy@gmail.com>
 *
 * GData Client is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * GData Client is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with GData Client.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * SECTION:gdata-commentable
 * @short_description: GData commentable interface
 * @stability: Stable
 * @include: gdata/gdata-commentable.h
 *
 * #GDataCommentable is an interface which can be implemented by commentable objects: objects which support having comments added to them by users,
 * such as videos and photos.
 *
 * Comments may be queried, added and deleted. Note that they may not be edited.
 *
 * #GDataCommentable objects may not support all operations on comments, on an instance-by-instance basis (i.e. it's an invalid assumption that if,
 * for example, one #GDataYouTubeVideo doesn't support adding comments all other #GDataYouTubeVideos don't support adding comments either).
 * Specific documentation for a particular type of #GDataCommentable may state otherwise, though.
 *
 * <example>
 * 	<title>Querying for Comments</title>
 * 	<programlisting>
 *	GDataService *service;
 *	GDataCommentable *commentable;
 *
 *	/<!-- -->* Create a service *<!-- -->/
 *	service = create_service ();
 *
 *	/<!-- -->* Retrieve the GDataCommentable which is going to be queried. This may be, for example, a GDataYouTubeVideo. *<!-- -->/
 *	commentable = get_commentable ();
 *
 *	/<!-- -->* Start the async. query for the comments. *<!-- -->/
 *	gdata_commentable_query_comments_async (commentable, service, NULL, NULL, NULL, NULL, NULL, (GAsyncReadyCallback) query_comments_cb, NULL);
 *
 *	g_object_unref (service);
 *	g_object_unref (commentable);
 *
 *	static void
 *	query_comments_cb (GDataCommentable *commentable, GAsyncResult *result, gpointer user_data)
 *	{
 *		GDataFeed *comment_feed;
 *		GList *comments, *i;
 *		GError *error = NULL;
 *
 *		comment_feed = gdata_commentable_query_comments_finish (commentable, result, &error);
 *
 *		if (error != NULL) {
 *			/<!-- -->* Error! *<!-- -->/
 *			g_error ("Error querying comments: %s", error->message);
 *			g_error_free (error);
 *			return;
 *		}
 *
 *		/<!-- -->* Examine the comments. *<!-- -->/
 *		comments = gdata_feed_get_entries (comment_feed);
 *		for (i = comments; i != NULL; i = i->next) {
 *			/<!-- -->* Note that this will actually be a subclass of GDataComment,
 *			 * such as GDataYouTubeComment or GDataPicasaWebComment. *<!-- -->/
 *			GDataComment *comment = GDATA_COMMENT (i->data);
 *			GDataAuthor *author;
 *
 *			/<!-- -->* Note that in practice it might not always be safe to assume that a comment always has an author. *<!-- -->/
 *			author = GDATA_AUTHOR (gdata_entry_get_authors (GDATA_ENTRY (comment))->data);
 *
 *			g_message ("Comment by %s (%s): %s",
 *			           gdata_author_get_name (author),
 *			           gdata_author_get_uri (author),
 *			           gdata_entry_get_content (GDATA_ENTRY (comment)));
 *		}
 *
 *		g_object_unref (comment_feed);
 *	}
 * 	</programlisting>
 * </example>
 *
 * Since: 0.10.0
 */

#include <config.h>
#include <glib.h>
#include <glib/gi18n-lib.h>
#include <string.h>

#include "gdata-commentable.h"
#include "gdata-service.h"

G_DEFINE_INTERFACE (GDataCommentable, gdata_commentable, GDATA_TYPE_ENTRY)

static void
gdata_commentable_default_init (GDataCommentableInterface *iface)
{
	iface->comment_type = G_TYPE_INVALID;
	iface->get_authorization_domain = NULL;
	iface->get_query_comments_uri = NULL;
	iface->get_insert_comment_uri = NULL;
	iface->is_comment_deletable = NULL;
}

static GType
get_comment_type (GDataCommentableInterface *iface)
{
	GType comment_type;

	comment_type = iface->comment_type;
	g_assert (g_type_is_a (comment_type, GDATA_TYPE_COMMENT) == TRUE);

	return comment_type;
}

/**
 * gdata_commentable_query_comments:
 * @self: a #GDataCommentable
 * @service: a #GDataService representing the service with which the object's comments will be manipulated
 * @query: (allow-none): a #GDataQuery with query parameters, or %NULL
 * @cancellable: (allow-none): optional #GCancellable object, or %NULL
 * @progress_callback: (allow-none) (scope call) (closure progress_user_data): a #GDataQueryProgressCallback to call when a comment is loaded, or %NULL
 * @progress_user_data: (closure): data to pass to the @progress_callback function
 * @error: a #GError, or %NULL
 *
 * Retrieves a #GDataFeed containing the #GDataComments representing the comments on the #GDataCommentable which match the given @query.
 *
 * If the #GDataCommentable doesn't support commenting, %NULL will be returned and @error will be set to %GDATA_SERVICE_ERROR_FORBIDDEN. This is in
 * contrast to if it does support commenting but hasn't had any comments added yet, in which case an empty #GDataFeed will be returned and no error
 * will be set.
 *
 * Return value: (transfer full) (allow-none): a #GDataFeed of #GDataComments, or %NULL; unref with g_object_unref()
 *
 * Since: 0.10.0
 */
GDataFeed *
gdata_commentable_query_comments (GDataCommentable *self, GDataService *service, GDataQuery *query,
                                  GCancellable *cancellable, GDataQueryProgressCallback progress_callback,
                                  gpointer progress_user_data, GError **error)
{
	GDataCommentableInterface *iface;
	gchar *uri;
	GDataFeed *feed;
	GDataAuthorizationDomain *domain = NULL;

	g_return_val_if_fail (GDATA_IS_COMMENTABLE (self), NULL);
	g_return_val_if_fail (GDATA_IS_SERVICE (service), NULL);
	g_return_val_if_fail (query == NULL || GDATA_IS_QUERY (query), NULL);
	g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
	g_return_val_if_fail (error == NULL || *error == NULL, NULL);

	iface = GDATA_COMMENTABLE_GET_IFACE (self);

	/* Get the comment feed URI. */
	g_assert (iface->get_query_comments_uri != NULL);
	uri = iface->get_query_comments_uri (self);

	/* The URI can be NULL when no comments and thus no feedLink is present in a GDataCommentable */
	if (uri == NULL) {
		/* Translators: This is an error message for if a user attempts to retrieve comments from an entry (such as a video) which doesn't
		 * support comments. */
		g_set_error_literal (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_FORBIDDEN, _("This entry does not support comments."));
		return NULL;
	}

	/* Get the authorisation domain. */
	if (iface->get_authorization_domain != NULL) {
		domain = iface->get_authorization_domain (self);
	}

	/* Get the comment feed. */
	feed = gdata_service_query (service, domain, uri, query, get_comment_type (iface), cancellable, progress_callback, progress_user_data, error);
	g_free (uri);

	return feed;
}

static void
query_comments_async_cb (GDataService *service, GAsyncResult *service_result, gpointer user_data)
{
	g_autoptr(GTask) commentable_task = G_TASK (user_data);
	g_autoptr(GDataFeed) feed = NULL;
	g_autoptr(GError) error = NULL;

	feed = gdata_service_query_finish (service, service_result, &error);

	if (error != NULL)
		g_task_return_error (commentable_task, g_steal_pointer (&error));
	else
		g_task_return_pointer (commentable_task, g_steal_pointer (&feed), g_object_unref);
}

/**
 * gdata_commentable_query_comments_async:
 * @self: a #GDataCommentable
 * @service: a #GDataService representing the service with which the object's comments will be manipulated
 * @query: (allow-none): a #GDataQuery with query parameters, or %NULL
 * @cancellable: (allow-none): optional #GCancellable object, or %NULL
 * @progress_callback: (allow-none) (scope notified) (closure progress_user_data): a #GDataQueryProgressCallback to call when a comment is loaded,
 * or %NULL
 * @progress_user_data: (closure): data to pass to the @progress_callback function
 * @destroy_progress_user_data: (allow-none): a function to call when @progress_callback will not be called any more, or %NULL; this function will be
 * called with @progress_user_data as a parameter and can be used to free any memory allocated for it
 * @callback: a #GAsyncReadyCallback to call when the query is finished
 * @user_data: (closure): data to pass to the @callback function
 *
 * Retrieves a #GDataFeed containing the #GDataComments representing the comments on the #GDataCommentable which match the given @query.
 * @self, @service and @query are all reffed when this method is called, so can safely be freed after this method returns.
 *
 * For more details, see gdata_commentable_query_comments(), which is the synchronous version of this method.
 *
 * When the operation is finished, @callback will be called. You can then call gdata_commentable_query_comments_finish() to get the results of the
 * operation.
 *
 * Since: 0.10.0
 */
void
gdata_commentable_query_comments_async (GDataCommentable *self, GDataService *service, GDataQuery *query, GCancellable *cancellable,
                                        GDataQueryProgressCallback progress_callback, gpointer progress_user_data,
                                        GDestroyNotify destroy_progress_user_data, GAsyncReadyCallback callback, gpointer user_data)
{
	GDataCommentableInterface *iface;
	gchar *uri;
	g_autoptr(GTask) task = NULL;
	GDataAuthorizationDomain *domain = NULL;

	g_return_if_fail (GDATA_IS_COMMENTABLE (self));
	g_return_if_fail (GDATA_IS_SERVICE (service));
	g_return_if_fail (query == NULL || GDATA_IS_QUERY (query));
	g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
	g_return_if_fail (callback != NULL);

	iface = GDATA_COMMENTABLE_GET_IFACE (self);

	/* Get the comment feed URI. */
	g_assert (iface->get_query_comments_uri != NULL);
	uri = iface->get_query_comments_uri (self);

	/* Build the async result. */
	task = g_task_new (self, cancellable, callback, user_data);
	g_task_set_source_tag (task, gdata_commentable_query_comments_async);

	/* The URI can be NULL when no comments and thus no feedLink is present in a GDataCommentable */
	if (uri == NULL) {
		g_task_return_new_error (task, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_FORBIDDEN,
		                         /* Translators: This is an error message for if a user attempts to retrieve comments from an entry
		                          * (such as a video) which doesn't support comments. */
		                         _("This entry does not support comments."));
		return;
	}

	/* Get the authorisation domain. */
	if (iface->get_authorization_domain != NULL) {
		domain = iface->get_authorization_domain (self);
	}

	/* Get the comment feed. */
	gdata_service_query_async (service, domain, uri, query, get_comment_type (iface), cancellable, progress_callback, progress_user_data,
	                           destroy_progress_user_data, (GAsyncReadyCallback) query_comments_async_cb, g_object_ref (task));
	g_free (uri);
}

/**
 * gdata_commentable_query_comments_finish:
 * @self: a #GDataCommentable
 * @result: a #GAsyncResult
 * @error: a #GError, or %NULL
 *
 * Finishes an asynchronous comment query operation started with gdata_commentable_query_comments_async().
 *
 * Return value: (transfer full) (allow-none): a #GDataFeed of #GDataComments, or %NULL; unref with g_object_unref()
 *
 * Since: 0.10.0
 */
GDataFeed *
gdata_commentable_query_comments_finish (GDataCommentable *self, GAsyncResult *result, GError **error)
{
	g_return_val_if_fail (GDATA_IS_COMMENTABLE (self), NULL);
	g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
	g_return_val_if_fail (g_task_is_valid (result, self), NULL);
	g_return_val_if_fail (g_async_result_is_tagged (result, gdata_commentable_query_comments_async), NULL);

	return g_task_propagate_pointer (G_TASK (result), error);
}

/**
 * gdata_commentable_insert_comment:
 * @self: a #GDataCommentable
 * @service: a #GDataService with which the comment will be added
 * @comment_: a new comment to be added to the #GDataCommentable
 * @cancellable: (allow-none): optional #GCancellable object, or %NULL
 * @error: a #GError, or %NULL
 *
 * Adds @comment to the #GDataCommentable.
 *
 * If the #GDataCommentable doesn't support commenting, %NULL will be returned and @error will be set to %GDATA_SERVICE_ERROR_FORBIDDEN.
 *
 * Return value: (transfer full) (allow-none): the added #GDataComment, or %NULL; unref with g_object_unref()
 *
 * Since: 0.10.0
 */
GDataComment *
gdata_commentable_insert_comment (GDataCommentable *self, GDataService *service, GDataComment *comment_, GCancellable *cancellable, GError **error)
{
	GDataCommentableInterface *iface;
	gchar *uri;
	GDataComment *new_comment;
	GDataAuthorizationDomain *domain = NULL;

	g_return_val_if_fail (GDATA_IS_COMMENTABLE (self), NULL);
	g_return_val_if_fail (GDATA_IS_SERVICE (service), NULL);
	g_return_val_if_fail (GDATA_IS_COMMENT (comment_), NULL);
	g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
	g_return_val_if_fail (error == NULL || *error == NULL, NULL);

	iface = GDATA_COMMENTABLE_GET_IFACE (self);

	g_return_val_if_fail (g_type_is_a (G_OBJECT_TYPE (comment_), get_comment_type (iface)) == TRUE, NULL);

	/* Get the upload URI. */
	g_assert (iface->get_insert_comment_uri != NULL);
	uri = iface->get_insert_comment_uri (self, comment_);

	if (uri == NULL) {
		/* Translators: This is an error message for if a user attempts to add a comment to an entry (such as a video) which doesn't support
		 * comments. */
		g_set_error_literal (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_FORBIDDEN, _("Comments may not be added to this entry."));
		return NULL;
	}

	/* Get the authorisation domain. */
	if (iface->get_authorization_domain != NULL) {
		domain = iface->get_authorization_domain (self);
	}

	/* Add the comment. */
	new_comment = GDATA_COMMENT (gdata_service_insert_entry (service, domain, uri, GDATA_ENTRY (comment_), cancellable, error));

	g_free (uri);

	return new_comment;
}

static void
insert_comment_async_cb (GDataService *service, GAsyncResult *service_result, gpointer user_data)
{
	g_autoptr(GTask) commentable_task = G_TASK (user_data);
	g_autoptr(GDataEntry) new_comment = NULL;
	g_autoptr(GError) error = NULL;

	new_comment = gdata_service_insert_entry_finish (service, service_result, &error);

	if (error != NULL)
		g_task_return_error (commentable_task, g_steal_pointer (&error));
	else
		g_task_return_pointer (commentable_task, g_steal_pointer (&new_comment), g_object_unref);
}

/**
 * gdata_commentable_insert_comment_async:
 * @self: a #GDataCommentable
 * @service: a #GDataService with which the comment will be added
 * @comment_: a new comment to be added to the #GDataCommentable
 * @cancellable: (allow-none): optional #GCancellable object, or %NULL
 * @callback: a #GAsyncReadyCallback to call when the operation is finished
 * @user_data: (closure): data to pass to the @callback function
 *
 * Adds @comment to the #GDataCommentable. @self, @service and @comment_ are all reffed when this method is called, so can safely be freed after this
 * method returns.
 *
 * For more details, see gdata_commentable_insert_comment(), which is the synchronous version of this method.
 *
 * When the operation is finished, @callback will be called. You can then call gdata_commentable_insert_comment_finish() to get the results of the
 * operation.
 *
 * Since: 0.10.0
 */
void
gdata_commentable_insert_comment_async (GDataCommentable *self, GDataService *service, GDataComment *comment_, GCancellable *cancellable,
                                        GAsyncReadyCallback callback, gpointer user_data)
{
	GDataCommentableInterface *iface;
	g_autofree gchar *uri = NULL;
	g_autoptr(GTask) task = NULL;
	GDataAuthorizationDomain *domain = NULL;

	g_return_if_fail (GDATA_IS_COMMENTABLE (self));
	g_return_if_fail (GDATA_IS_SERVICE (service));
	g_return_if_fail (GDATA_IS_COMMENT (comment_));
	g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));

	iface = GDATA_COMMENTABLE_GET_IFACE (self);

	g_return_if_fail (g_type_is_a (G_OBJECT_TYPE (comment_), get_comment_type (iface)) == TRUE);

	/* Get the upload URI. */
	g_assert (iface->get_insert_comment_uri != NULL);
	uri = iface->get_insert_comment_uri (self, comment_);

	/* Build the async result. */
	task = g_task_new (self, cancellable, callback, user_data);
	g_task_set_source_tag (task, gdata_commentable_insert_comment_async);

	/* The URI can be NULL when no comments and thus no feedLink is present in a GDataCommentable */
	if (uri == NULL) {
		g_task_return_new_error (task, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_FORBIDDEN,
		                         /* Translators: This is an error message for if a user attempts to add a comment to an entry
		                          * (such as a video) which doesn't support comments. */
		                         _("Comments may not be added to this entry."));
		return;
	}

	/* Get the authorisation domain. */
	if (iface->get_authorization_domain != NULL) {
		domain = iface->get_authorization_domain (self);
	}

	/* Add the comment. */
	gdata_service_insert_entry_async (service, domain, uri, GDATA_ENTRY (comment_), cancellable, (GAsyncReadyCallback) insert_comment_async_cb,
	                                  g_object_ref (task));
}

/**
 * gdata_commentable_insert_comment_finish:
 * @self: a #GDataCommentable
 * @result: a #GAsyncResult
 * @error: a #GError, or %NULL
 *
 * Finishes an asynchronous comment insertion operation started with gdata_commentable_insert_comment_async().
 *
 * Return value: (transfer full) (allow-none): the added #GDataComment, or %NULL; unref with g_object_unref()
 *
 * Since: 0.10.0
 */
GDataComment *
gdata_commentable_insert_comment_finish (GDataCommentable *self, GAsyncResult *result, GError **error)
{
	g_return_val_if_fail (GDATA_IS_COMMENTABLE (self), NULL);
	g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
	g_return_val_if_fail (g_task_is_valid (result, self), NULL);
	g_return_val_if_fail (g_async_result_is_tagged (result, gdata_commentable_insert_comment_async), NULL);

	return g_task_propagate_pointer (G_TASK (result), error);
}

/**
 * gdata_commentable_delete_comment:
 * @self: a #GDataCommentable
 * @service: a #GDataService with which the comment will be deleted
 * @comment_: a comment to be deleted
 * @cancellable: (allow-none): optional #GCancellable object, or %NULL
 * @error: a #GError, or %NULL
 *
 * Deletes @comment from the #GDataCommentable.
 *
 * If the given @comment isn't deletable (either because the service doesn't support deleting comments at all, or because this particular comment
 * is not deletable due to having insufficient permissions), %GDATA_SERVICE_ERROR_FORBIDDEN will be set in @error and %FALSE will be returned.
 *
 * Return value: %TRUE if the comment was successfully deleted, %FALSE otherwise
 *
 * Since: 0.10.0
 */
gboolean
gdata_commentable_delete_comment (GDataCommentable *self, GDataService *service, GDataComment *comment_, GCancellable *cancellable, GError **error)
{
	GDataCommentableInterface *iface;
	GDataAuthorizationDomain *domain = NULL;

	g_return_val_if_fail (GDATA_IS_COMMENTABLE (self), FALSE);
	g_return_val_if_fail (GDATA_IS_SERVICE (service), FALSE);
	g_return_val_if_fail (GDATA_IS_COMMENT (comment_), FALSE);
	g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

	iface = GDATA_COMMENTABLE_GET_IFACE (self);

	g_return_val_if_fail (g_type_is_a (G_OBJECT_TYPE (comment_), get_comment_type (iface)) == TRUE, FALSE);

	g_assert (iface->is_comment_deletable != NULL);
	if (iface->is_comment_deletable (self, comment_) == FALSE) {
		/* Translators: This is an error message for if a user attempts to delete a comment they're not allowed to delete. */
		g_set_error_literal (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_FORBIDDEN, _("This comment may not be deleted."));
		return FALSE;
	}

	/* Get the authorisation domain. */
	if (iface->get_authorization_domain != NULL) {
		domain = iface->get_authorization_domain (self);
	}

	/* Delete the comment. */
	return gdata_service_delete_entry (service, domain, GDATA_ENTRY (comment_), cancellable, error);
}

static void
delete_comment_async_cb (GDataService *service, GAsyncResult *service_result, gpointer user_data)
{
	g_autoptr(GTask) commentable_task = G_TASK (user_data);
	g_autoptr(GError) error = NULL;

	if (!gdata_service_delete_entry_finish (service, service_result, &error))
		g_task_return_error (commentable_task, g_steal_pointer (&error));
	else
		g_task_return_boolean (commentable_task, TRUE);
}

/**
 * gdata_commentable_delete_comment_async:
 * @self: a #GDataCommentable
 * @service: a #GDataService with which the comment will be deleted
 * @comment_: a comment to be deleted
 * @cancellable: (allow-none): optional #GCancellable object, or %NULL
 * @callback: a #GAsyncReadyCallback to call when the operation is finished
 * @user_data: (closure): data to pass to the @callback function
 *
 * Deletes @comment from the #GDataCommentable. @self, @service and @comment_ are all reffed when this method is called, so can safely be freed after
 * this method returns.
 *
 * For more details, see gdata_commentable_delete_comment(), which is the synchronous version of this method.
 *
 * When the operation is finished, @callback will be called. You can then call gdata_commentable_delete_comment_finish() to get the results of the
 * operation.
 *
 * Since: 0.10.0
 */
void
gdata_commentable_delete_comment_async (GDataCommentable *self, GDataService *service, GDataComment *comment_, GCancellable *cancellable,
                                        GAsyncReadyCallback callback, gpointer user_data)
{
	GDataCommentableInterface *iface;
	g_autoptr(GTask) task = NULL;
	GDataAuthorizationDomain *domain = NULL;

	g_return_if_fail (GDATA_IS_COMMENTABLE (self));
	g_return_if_fail (GDATA_IS_SERVICE (service));
	g_return_if_fail (GDATA_IS_COMMENT (comment_));
	g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));

	iface = GDATA_COMMENTABLE_GET_IFACE (self);

	g_return_if_fail (g_type_is_a (G_OBJECT_TYPE (comment_), get_comment_type (iface)) == TRUE);

	/* Build the async result. */
	task = g_task_new (self, cancellable, callback, user_data);
	g_task_set_source_tag (task, gdata_commentable_delete_comment_async);

	g_assert (iface->is_comment_deletable != NULL);
	if (iface->is_comment_deletable (self, comment_) == FALSE) {
		g_task_return_new_error (task, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_FORBIDDEN,
		                         /* Translators: This is an error message for if a user attempts to delete a comment they're not allowed to delete. */
		                         _("This comment may not be deleted."));
		return;
	}

	/* Get the authorisation domain. */
	if (iface->get_authorization_domain != NULL) {
		domain = iface->get_authorization_domain (self);
	}

	/* Delete the comment. */
	gdata_service_delete_entry_async (service, domain, GDATA_ENTRY (comment_), cancellable, (GAsyncReadyCallback) delete_comment_async_cb, g_object_ref (task));
}

/**
 * gdata_commentable_delete_comment_finish:
 * @self: a #GDataCommentable
 * @result: a #GAsyncResult
 * @error: a #GError, or %NULL
 *
 * Finishes an asynchronous comment deletion operation started with gdata_commentable_delete_comment_async().
 *
 * Return value: %TRUE if the comment was successfully deleted, %FALSE otherwise
 *
 * Since: 0.10.0
 */
gboolean
gdata_commentable_delete_comment_finish (GDataCommentable *self, GAsyncResult *result, GError **error)
{
	g_return_val_if_fail (GDATA_IS_COMMENTABLE (self), FALSE);
	g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
	g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
	g_return_val_if_fail (g_async_result_is_tagged (result, gdata_commentable_delete_comment_async), FALSE);

	return g_task_propagate_boolean (G_TASK (result), error);
}