/**
* grl_related_keys_dup:
* @relkeys: set of related keys to duplicate
*
* Makes a deep copy of @relkeys and its contents.
*
* Returns: (transfer full): a new #GrlRelatedKeys.
* Free it with #g_object_unref.
*
* Since: 0.1.10
**/
GrlRelatedKeys *
grl_related_keys_dup (GrlRelatedKeys *relkeys)
{
GList *keys, *key;
const GValue *value;
GValue *value_copy;
GrlRelatedKeys *dup_relkeys;
g_return_val_if_fail (GRL_IS_RELATED_KEYS (relkeys), NULL);
dup_relkeys = grl_related_keys_new ();
keys = grl_related_keys_get_keys (relkeys);
for (key = keys; key; key = g_list_next (key)) {
value = grl_related_keys_get (relkeys, GRLPOINTER_TO_KEYID (key->data));
value_copy = g_new0 (GValue, 1);
g_value_init (value_copy, G_VALUE_TYPE (value));
g_value_copy (value, value_copy);
g_hash_table_insert (dup_relkeys->priv->data, key->data, value_copy);
}
g_list_free (keys);
return dup_relkeys;
}
static void
grl_gravatar_source_resolve (GrlSource *source,
GrlSourceResolveSpec *rs)
{
gboolean artist_avatar_required = FALSE;
gboolean author_avatar_required = FALSE;
GRL_DEBUG (__FUNCTION__);
GList *iter;
/* Check that albumart is requested */
iter = rs->keys;
while (iter && (!artist_avatar_required || !author_avatar_required)) {
GrlKeyID key = GRLPOINTER_TO_KEYID (iter->data);
if (key == GRL_METADATA_KEY_ARTIST_AVATAR) {
artist_avatar_required = TRUE;
} else if (key == GRL_METADATA_KEY_AUTHOR_AVATAR) {
author_avatar_required = TRUE;
}
iter = g_list_next (iter);
}
if (artist_avatar_required) {
set_avatar (GRL_DATA (rs->media), GRL_METADATA_KEY_ARTIST);
}
if (author_avatar_required) {
set_avatar (GRL_DATA (rs->media), GRL_METADATA_KEY_AUTHOR);
}
rs->callback (source, rs->operation_id, rs->media, rs->user_data, NULL);
}
static resolution_flags_t
get_resolution_flags (GList *keys,
GrlLocalMetadataSourcePriv *priv)
{
GList *iter = keys;
resolution_flags_t flags = 0;
while (iter != NULL) {
GrlKeyID key = GRLPOINTER_TO_KEYID (iter->data);
if (key == GRL_METADATA_KEY_TITLE)
flags |= FLAG_VIDEO_TITLE;
else if (key == GRL_METADATA_KEY_SHOW)
flags |= FLAG_VIDEO_SHOWNAME;
else if (key == GRL_METADATA_KEY_PUBLICATION_DATE)
flags |= FLAG_VIDEO_DATE;
else if (key == GRL_METADATA_KEY_SEASON)
flags |= FLAG_VIDEO_SEASON;
else if (key == GRL_METADATA_KEY_EPISODE)
flags |= FLAG_VIDEO_EPISODE;
else if (key == GRL_METADATA_KEY_THUMBNAIL)
flags |= FLAG_THUMBNAIL;
else if (key == priv->hash_keyid)
flags |= FLAG_GIBEST_HASH;
else if (key == GRL_METADATA_KEY_EPISODE_TITLE)
flags |= FLAG_VIDEO_EPISODE_TITLE;
iter = iter->next;
}
return flags;
}
gchar *
grl_tracker_get_delete_string (const GList *keys)
{
gboolean first = TRUE;
const GList *key = keys, *assoc_list;
tracker_grl_sparql_t *assoc;
GString *gstr = g_string_new ("");
gchar *ret;
gint var_n = 0;
while (key != NULL) {
assoc_list = get_mapping_from_grl (GRLPOINTER_TO_KEYID (key->data));
while (assoc_list != NULL) {
assoc = (tracker_grl_sparql_t *) assoc_list->data;
if (assoc != NULL) {
if (first) {
g_string_append_printf (gstr, "%s ?v%i",
assoc->sparql_key_attr, var_n);
first = FALSE;
} else {
g_string_append_printf (gstr, " ; %s ?v%i",
assoc->sparql_key_attr, var_n);
}
var_n++;
}
assoc_list = assoc_list->next;
}
key = key->next;
}
ret = gstr->str;
g_string_free (gstr, FALSE);
return ret;
}
gchar *
grl_tracker_source_get_select_string (const GList *keys)
{
const GList *key = keys;
GString *gstr = g_string_new ("");
GList *assoc_list;
tracker_grl_sparql_t *assoc;
assoc_list = get_mapping_from_grl (grl_metadata_key_tracker_urn);
assoc = (tracker_grl_sparql_t *) assoc_list->data;
g_string_append_printf (gstr, "%s AS %s ",
assoc->sparql_key_attr_call,
assoc->sparql_key_name);
while (key != NULL) {
assoc_list = get_mapping_from_grl (GRLPOINTER_TO_KEYID (key->data));
while (assoc_list != NULL) {
assoc = (tracker_grl_sparql_t *) assoc_list->data;
if (assoc != NULL) {
g_string_append_printf (gstr, "%s AS %s ",
assoc->sparql_key_attr_call,
assoc->sparql_key_name);
}
assoc_list = assoc_list->next;
}
key = key->next;
}
return g_string_free (gstr, FALSE);
}
gchar *
grl_tracker_tracker_get_insert_string (GrlMedia *media, const GList *keys)
{
gboolean first = TRUE;
const GList *key;
GString *gstr = g_string_new ("");
for (key = keys; key != NULL; key = key->next) {
const GList *assoc_list;
GrlKeyID key_id = GRLPOINTER_TO_KEYID (key->data);
for (assoc_list = get_mapping_from_grl (key_id);
assoc_list != NULL;
assoc_list = assoc_list->next) {
tracker_grl_sparql_t *assoc = assoc_list->data;
if (assoc == NULL)
continue;
/* The favourite key is really setting or deleting a tag
* in tracker, so in the case of setting it to false skip
* the insert string creation step for this key completely.
*/
if (assoc->grl_key == GRL_METADATA_KEY_FAVOURITE &&
!grl_media_get_favourite (media))
continue;
if (!grl_data_has_key (GRL_DATA (media), key_id))
continue;
if (!first)
g_string_append (gstr, " ; ");
gen_prop_insert_string (gstr, assoc, GRL_DATA (media));
first = FALSE;
}
}
return g_string_free (gstr, FALSE);
}
static void
fill_metadata_from_stmt (GrlMedia *media, GList *keys, sqlite3_stmt *stmt)
{
GList *iter;
gint play_count, last_position, favourite;
gdouble rating;
gchar *last_played;
iter = keys;
while (iter) {
GrlKeyID key = GRLPOINTER_TO_KEYID (iter->data);
if (key == GRL_METADATA_KEY_PLAY_COUNT) {
play_count = sqlite3_column_int (stmt, STORE_PLAY_COUNT);
grl_media_set_play_count (media, play_count);
} else if (key == GRL_METADATA_KEY_RATING) {
rating = sqlite3_column_double (stmt, STORE_RATING);
grl_media_set_rating (media, rating, 5.00);
} else if (key == GRL_METADATA_KEY_LAST_PLAYED) {
GDateTime *date;
last_played = (gchar *) sqlite3_column_text (stmt, STORE_LAST_PLAYED);
date = grl_date_time_from_iso8601 (last_played);
if (date) {
grl_media_set_last_played (media, date);
g_date_time_unref (date);
} else {
GRL_WARNING ("Unable to set 'last-played', as '%s' date is invalid",
last_played);
}
} else if (key == GRL_METADATA_KEY_LAST_POSITION) {
last_position = sqlite3_column_int (stmt, STORE_LAST_POSITION);
grl_media_set_last_position (media, last_position);
} else if (key == GRL_METADATA_KEY_FAVOURITE) {
favourite = sqlite3_column_int (stmt, STORE_FAVOURITE);
grl_media_set_favourite (media, (gboolean) favourite);
}
iter = g_list_next (iter);
}
}
static GList *
write_keys (sqlite3 *db,
const gchar *source_id,
const gchar *media_id,
GrlSourceStoreMetadataSpec *sms,
GError **error)
{
GList *col_names = NULL;
GList *iter;
GList *failed_keys = NULL;
guint supported_keys = 0;
gint r;
/* Get DB column names for each key to be updated */
iter = sms->keys;
while (iter) {
const gchar *col_name =
get_column_name_from_key_id (GRLPOINTER_TO_KEYID (iter->data));
if (!col_name) {
GRL_WARNING ("Key %" GRL_KEYID_FORMAT " is not supported for "
"writing, ignoring...",
GRLPOINTER_TO_KEYID (iter->data));
failed_keys = g_list_prepend (failed_keys, iter->data);
} else {
supported_keys++;
}
col_names = g_list_prepend (col_names, (gchar *) col_name);
iter = g_list_next (iter);
}
col_names = g_list_reverse (col_names);
if (supported_keys == 0) {
GRL_WARNING ("Failed to update metadata, none of the specified "
"keys is writable");
*error = g_error_new (GRL_CORE_ERROR,
GRL_CORE_ERROR_STORE_METADATA_FAILED,
_("Failed to update metadata: %s"),
_("specified keys are not writable"));
goto done;
}
r = prepare_and_exec_update (db,
source_id,
media_id,
col_names,
sms->keys,
sms->media);
if (!r) {
GRL_WARNING ("Failed to update metadata for '%s - %s': %s",
source_id, media_id, sqlite3_errmsg (db));
g_list_free (failed_keys);
failed_keys = g_list_copy (sms->keys);
*error = g_error_new (GRL_CORE_ERROR,
GRL_CORE_ERROR_STORE_METADATA_FAILED,
_("Failed to update metadata: %s"),
sqlite3_errmsg (db));
goto done;
}
if (sqlite3_changes (db) == 0) {
/* We have to create the row */
r = prepare_and_exec_insert (db,
source_id,
media_id,
col_names,
sms->keys,
sms->media);
}
if (!r) {
GRL_WARNING ("Failed to update metadata for '%s - %s': %s",
source_id, media_id, sqlite3_errmsg (db));
g_list_free (failed_keys);
failed_keys = g_list_copy (sms->keys);
*error = g_error_new_literal (GRL_CORE_ERROR,
GRL_CORE_ERROR_STORE_METADATA_FAILED,
_("Failed to update metadata"));
goto done;
}
done:
g_list_free (col_names);
return failed_keys;
}
static gboolean
bind_and_exec (sqlite3 *db,
const gchar *sql,
const gchar *source_id,
const gchar *media_id,
GList *col_names,
GList *keys,
GrlMedia *media)
{
gint r;
const gchar *char_value;
gint int_value;
double double_value;
GList *iter_names, *iter_keys;
guint count;
sqlite3_stmt *stmt;
/* Create statement from sql */
GRL_DEBUG ("%s", sql);
r = sqlite3_prepare_v2 (db, sql, strlen (sql), &stmt, NULL);
if (r != SQLITE_OK) {
GRL_WARNING ("Failed to update metadata for '%s - %s': %s",
source_id, media_id, sqlite3_errmsg (db));
sqlite3_finalize (stmt);
return FALSE;
}
/* Bind media type */
sqlite3_bind_int (stmt, 1, get_media_type (media));
/* Bind column values */
count = 2;
iter_names = col_names;
iter_keys = keys;
while (iter_names) {
if (iter_names->data) {
GrlKeyID key = GRLPOINTER_TO_KEYID (iter_keys->data);
if (key == GRL_METADATA_KEY_RATING) {
double_value = grl_media_get_rating (media);
sqlite3_bind_double (stmt, count, double_value);
} else if (key == GRL_METADATA_KEY_PLAY_COUNT) {
int_value = grl_media_get_play_count (media);
sqlite3_bind_int (stmt, count, int_value);
} else if (key == GRL_METADATA_KEY_LAST_POSITION) {
int_value = grl_media_get_last_position (media);
sqlite3_bind_int (stmt, count, int_value);
} else if (key == GRL_METADATA_KEY_LAST_PLAYED) {
char_value = grl_media_get_last_played (media);
sqlite3_bind_text (stmt, count, char_value, -1, SQLITE_STATIC);
} else if (key == GRL_METADATA_KEY_FAVOURITE) {
int_value = (gint) grl_media_get_favourite (media);
sqlite3_bind_int (stmt, count, int_value);
}
count++;
}
iter_keys = g_list_next (iter_keys);
iter_names = g_list_next (iter_names);
}
sqlite3_bind_text (stmt, count++, source_id, -1, SQLITE_STATIC);
sqlite3_bind_text (stmt, count++, media_id, -1, SQLITE_STATIC);
/* execute query */
while ((r = sqlite3_step (stmt)) == SQLITE_BUSY);
sqlite3_finalize (stmt);
return (r == SQLITE_DONE);
}
static void
fill_properties_table (MS2Server *server,
GHashTable *properties_table,
GList *keys,
GrlMedia *media)
{
GList *prop;
GrlKeyID key;
const gchar *title;
gchar *id;
gchar *urls[2] = { 0 };
for (prop = keys; prop; prop = g_list_next (prop)) {
key = GRLPOINTER_TO_KEYID (prop->data);
if (key == GRL_METADATA_KEY_ID ||
grl_data_has_key (GRL_DATA (media), key)) {
if (key == GRL_METADATA_KEY_ID) {
id = serialize_media (media);
if (id) {
ms2_server_set_path (server,
properties_table,
id,
grl_media_is_container (media));
g_free (id);
}
} else if (key == GRL_METADATA_KEY_TITLE) {
/* Ensure we always insert a valid title */
title = grl_media_get_title (media);
if (!title) {
title = "Unknown";
}
ms2_server_set_display_name (server,
properties_table,
title);
} else if (key == GRL_METADATA_KEY_ALBUM) {
ms2_server_set_album (server,
properties_table,
grl_data_get_string (GRL_DATA (media),
GRL_METADATA_KEY_ALBUM));
} else if (key == GRL_METADATA_KEY_ARTIST) {
ms2_server_set_artist (server,
properties_table,
grl_data_get_string (GRL_DATA (media),
GRL_METADATA_KEY_ARTIST));
} else if (key == GRL_METADATA_KEY_GENRE) {
ms2_server_set_genre (server,
properties_table,
grl_data_get_string (GRL_DATA (media),
GRL_METADATA_KEY_GENRE));
} else if (key == GRL_METADATA_KEY_MIME) {
ms2_server_set_mime_type (server,
properties_table,
grl_media_get_mime (media));
} else if (key == GRL_METADATA_KEY_URL) {
urls[0] = (gchar *) grl_media_get_url (media);
ms2_server_set_urls (server, properties_table, urls);
} else if (key == GRL_METADATA_KEY_BITRATE) {
ms2_server_set_bitrate (server,
properties_table,
grl_data_get_int (GRL_DATA (media),
GRL_METADATA_KEY_BITRATE));
} else if (key == GRL_METADATA_KEY_DURATION) {
ms2_server_set_duration (server,
properties_table,
grl_media_get_duration (media));
} else if (key == GRL_METADATA_KEY_HEIGHT) {
ms2_server_set_height (server,
properties_table,
grl_data_get_int (GRL_DATA (media),
GRL_METADATA_KEY_HEIGHT));
} else if (key == GRL_METADATA_KEY_WIDTH) {
ms2_server_set_width (server,
properties_table,
grl_data_get_int (GRL_DATA (media),
GRL_METADATA_KEY_WIDTH));
} else if (key == GRL_METADATA_KEY_GRILO_MS2_PARENT) {
if (grl_media_get_id (media) == NULL) {
ms2_server_set_parent (server,
properties_table,
MS2_ROOT);
} else {
ms2_server_set_parent (server,
properties_table,
grl_media_get_grilo_ms2_parent (media));
}
}
}
}
}
/**
* grl_operation_options_obey_caps:
* @options: a #GrlOperationOptions instance
* @caps: capabilities against which we want to test @options
* @supported_options: (out callee-allocates): if not %NULL, will contain a
* newly-allocated #GrlOperationOptions instance containing all the values of
* @options that match @caps.
* @unsupported_options: (out callee-allocates): if not %NULL, will contain a
* newly-allocated #GrlOperationOptions instance containing all the values of
* @options that do not match @caps.
*
* Check whether @options obey to @caps.
* Optionally provide the options that match (respectively don't match) @caps
* in @supported_options (respectively @unsupported_options).
* This would typically (but not necessarily) be used with a
* #GrlOperationOptions instance that was created with %NULL caps.
*
* Returns: %TRUE if @options obey to @caps, %FALSE otherwise.
*
* Since: 0.2.0
*/
gboolean
grl_operation_options_obey_caps (GrlOperationOptions *options,
GrlCaps *caps,
GrlOperationOptions **supported_options,
GrlOperationOptions **unsupported_options)
{
gboolean ret = TRUE;
GHashTableIter table_iter;
gpointer key_ptr;
GValue *value;
GrlRangeValue *range_value;
if (supported_options) {
*supported_options = grl_operation_options_new (caps);
/* these options are always supported */
copy_option (options, *supported_options, GRL_OPERATION_OPTION_SKIP);
copy_option (options, *supported_options, GRL_OPERATION_OPTION_COUNT);
copy_option (options, *supported_options, GRL_OPERATION_OPTION_RESOLUTION_FLAGS);
}
if (unsupported_options)
*unsupported_options = grl_operation_options_new (NULL);
ret &= check_and_copy_option (options,
caps,
GRL_OPERATION_OPTION_TYPE_FILTER,
supported_options,
unsupported_options);
/* Check filter-by-equal-key */
g_hash_table_iter_init (&table_iter, options->priv->key_filter);
while (g_hash_table_iter_next (&table_iter, &key_ptr, (gpointer *)&value)) {
GrlKeyID key_id = GRLPOINTER_TO_KEYID (key_ptr);
if (grl_caps_is_key_filter (caps, key_id)) {
if (supported_options) {
g_hash_table_insert ((*supported_options)->priv->key_filter,
key_ptr,
grl_g_value_dup (value));
}
} else {
ret = FALSE;
if (unsupported_options) {
g_hash_table_insert ((*unsupported_options)->priv->key_filter,
key_ptr,
grl_g_value_dup (value));
}
}
}
/* Check filter-by-range-key */
g_hash_table_iter_init (&table_iter, options->priv->key_range_filter);
while (g_hash_table_iter_next (&table_iter, &key_ptr, (gpointer *)&range_value)) {
GrlKeyID key_id = GRLPOINTER_TO_KEYID (key_ptr);
if (grl_caps_is_key_range_filter (caps, key_id)) {
if (supported_options) {
g_hash_table_insert ((*supported_options)->priv->key_range_filter,
key_ptr,
grl_range_value_dup (range_value));
}
} else {
ret = FALSE;
if (unsupported_options) {
g_hash_table_insert ((*unsupported_options)->priv->key_range_filter,
key_ptr,
grl_range_value_dup (range_value));
}
}
}
return ret;
}
static void fill_key_id(gpointer data, gpointer user_data) {
QVariantList *varList = static_cast<QVariantList *>(user_data);
varList->append(GriloDataSource::MetadataKeys(GRLPOINTER_TO_KEYID(data)));
}