/**
* gfbgraph_connectable_default_parse_connected_data:
* @self: a #GFBGraphConnectable.
* @payload: a const #gchar with the response string from the Facebook Graph API.
* @error: (allow-none): a #GError or %NULL.
*
* In most cases, #GFBGraphConnectable implementers can use this function in order to parse
* the response when a gfbgraph_node_get_connection_nodes() is executed and the
* gfbgraph_connectable_parse_connected_data() was called.
*
* Normally, Facebook Graph API returns the connections in the same way, using JSON objects,
* with a root object called "data".
*
* Returns: (element-type GFBGraphNode) (transfer full): a newly-allocated #GList of #GFBGraphNode with the same #GType as @self.
**/
GList*
gfbgraph_connectable_default_parse_connected_data (GFBGraphConnectable *self, const gchar *payload, GError **error)
{
GList *nodes_list = NULL;
JsonParser *jparser;
GType node_type;
node_type = G_OBJECT_TYPE (self);
jparser = json_parser_new ();
if (json_parser_load_from_data (jparser, payload, -1, error)) {
JsonNode *root_jnode;
JsonObject *main_jobject;
JsonArray *nodes_jarray;
int i = 0;
root_jnode = json_parser_get_root (jparser);
main_jobject = json_node_get_object (root_jnode);
nodes_jarray = json_object_get_array_member (main_jobject, "data");
for (i = 0; i < json_array_get_length (nodes_jarray); i++) {
JsonNode *jnode;
GFBGraphNode *node;
jnode = json_array_get_element (nodes_jarray, i);
node = GFBGRAPH_NODE (json_gobject_deserialize (node_type, jnode));
nodes_list = g_list_append (nodes_list, node);
}
}
g_clear_object (&jparser);
return nodes_list;
}
static gboolean
parse_reviews (GsPlugin *plugin, JsonParser *parser, GsApp *app, GCancellable *cancellable, GError **error)
{
GsAuth *auth;
JsonArray *array;
const gchar *consumer_key = NULL;
guint i;
auth = gs_plugin_get_auth_by_id (plugin, "ubuntuone");
if (auth != NULL)
consumer_key = gs_auth_get_metadata_item (auth, "consumer-key");
if (!JSON_NODE_HOLDS_ARRAY (json_parser_get_root (parser)))
return FALSE;
array = json_node_get_array (json_parser_get_root (parser));
for (i = 0; i < json_array_get_length (array); i++) {
g_autoptr(AsReview) review = NULL;
/* Read in from JSON... (skip bad entries) */
review = as_review_new ();
if (parse_review (review, consumer_key, json_array_get_element (array, i)))
gs_app_add_review (app, review);
}
return TRUE;
}
static void
process_results (RBPodcastSearchITunes *search, JsonParser *parser)
{
JsonObject *container;
JsonArray *results;
guint i;
container = json_node_get_object (json_parser_get_root (parser));
results = json_node_get_array (json_object_get_member (container, "results"));
for (i = 0; i < json_array_get_length (results); i++) {
JsonObject *feed;
RBPodcastChannel *channel;
feed = json_array_get_object_element (results, i);
/* check wrapperType==track, kind==podcast ? */
channel = g_new0 (RBPodcastChannel, 1);
channel->url = g_strdup (json_object_get_string_member (feed, "collectionViewUrl"));
channel->title = g_strdup (json_object_get_string_member (feed, "collectionName"));
channel->author = g_strdup (json_object_get_string_member (feed, "artistName"));
channel->img = g_strdup (json_object_get_string_member (feed, "artworkUrl100")); /* 100? */
channel->is_opml = FALSE;
channel->num_posts = json_object_get_int_member (feed, "trackCount");
rb_debug ("got result %s (%s)", channel->title, channel->url);
rb_podcast_search_result (RB_PODCAST_SEARCH (search), channel);
rb_podcast_parse_channel_free (channel);
}
}
static void
skypeweb_got_authrequests(SkypeWebAccount *sa, JsonNode *node, gpointer user_data)
{
JsonArray *requests;
guint index, length;
time_t latest_timestamp = 0;
requests = json_node_get_array(node);
length = json_array_get_length(requests);
for(index = 0; index < length; index++)
{
JsonObject *request = json_array_get_object_element(requests, index);
const gchar *event_time_iso = json_object_get_string_member(request, "event_time_iso");
const gchar *sender = json_object_get_string_member(request, "sender");
const gchar *greeting = json_object_get_string_member(request, "greeting");
time_t event_timestamp = purple_str_to_time(event_time_iso, TRUE, NULL, NULL, NULL);
latest_timestamp = MAX(latest_timestamp, event_timestamp);
if (sa->last_authrequest && event_timestamp <= sa->last_authrequest)
continue;
purple_account_request_authorization(
sa->account, sender, NULL,
NULL, greeting, FALSE,
skypeweb_auth_accept_cb, skypeweb_auth_reject_cb, purple_buddy_new(sa->account, sender, NULL));
}
sa->last_authrequest = latest_timestamp;
}
static gboolean
update_for_meta (CockpitMetrics *self,
JsonObject *meta,
gboolean reset)
{
JsonArray *array;
JsonObject *info;
JsonArray *instances;
guint length;
gchar const *derive;
array = json_object_get_array_member (meta, "metrics");
g_return_val_if_fail (array != NULL, FALSE);
length = json_array_get_length (array);
if (self->priv->metric_info == NULL)
{
self->priv->n_metrics = length;
self->priv->metric_info = g_new0 (MetricInfo, length);
self->priv->last_data = g_new0 (double *, length);
self->priv->next_data = g_new0 (double *, length);
self->priv->derived = g_new0 (double *, length);
reset = TRUE;
}
/**
* json_reader_count_elements:
* @reader: a #JsonReader
*
* Counts the elements of the current position, if @reader is
* positioned on an array
*
* Return value: the number of elements, or -1. In case of failure
* the #JsonReader is set in an error state
*
* Since: 0.12
*/
gint
json_reader_count_elements (JsonReader *reader)
{
JsonReaderPrivate *priv;
g_return_val_if_fail (JSON_IS_READER (reader), -1);
priv = reader->priv;
if (priv->current_node == NULL)
{
json_reader_set_error (reader, JSON_READER_ERROR_INVALID_NODE,
_("No node available at the current position"));
return -1;
}
if (!JSON_NODE_HOLDS_ARRAY (priv->current_node))
{
json_reader_set_error (reader, JSON_READER_ERROR_NO_ARRAY,
_("The current position holds a '%s' and not an array"),
json_node_type_get_name (JSON_NODE_TYPE (priv->current_node)));
return -1;
}
return json_array_get_length (json_node_get_array (priv->current_node));
}
gboolean
_rpmostree_jsonutil_append_string_array_to (JsonObject *object,
const char *member_name,
GPtrArray *array,
GError **error)
{
JsonArray *jarray = json_object_get_array_member (object, member_name);
guint i, len;
if (!jarray)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"No member '%s' found", member_name);
return FALSE;
}
len = json_array_get_length (jarray);
for (i = 0; i < len; i++)
{
const char *v = _rpmostree_jsonutil_array_require_string_element (jarray, i, error);
if (!v)
return FALSE;
g_ptr_array_add (array, g_strdup (v));
}
return TRUE;
}
static gboolean
ipcam_event_cover_msg_handler_get_action_impl(IpcamMessageHandler *handler, JsonNode *request, JsonNode **response)
{
JsonBuilder *builder = json_builder_new();
JsonArray *req_array;
int i;
req_array = json_object_get_array_member(json_node_get_object(request), "items");
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "items");
json_builder_begin_object(builder);
for (i = 0; i < json_array_get_length(req_array); i++)
{
const gchar *name = json_array_get_string_element(req_array, i);
if (g_str_equal(name, "region1") ||
g_str_equal(name, "region2"))
{
json_builder_set_member_name(builder, name);
json_builder_begin_object(builder);
ipcam_event_cover_msg_handler_read_param(IPCAM_EVENT_COVER_MSG_HANDLER(handler), builder, name);
json_builder_end_object(builder);
}
}
json_builder_end_object(builder);
json_builder_end_object(builder);
*response = json_builder_get_root(builder);
g_object_unref(builder);
return TRUE;
}
static gboolean
parse_emojione_aliases_ascii (JsonNode *node,
EmojiData *data)
{
JsonArray *aliases_ascii;
guint i, length;
if (json_node_get_node_type (node) != JSON_NODE_ARRAY) {
g_warning ("'aliases_ascii' element is not array");
return FALSE;
}
aliases_ascii = json_node_get_array (node);
length = json_array_get_length (aliases_ascii);
for (i = 0; i < length; i++) {
const gchar *alias = json_array_get_string_element (aliases_ascii, i);
GSList *duplicated = g_slist_find_custom (data->annotations,
alias,
(GCompareFunc) g_strcmp0);
if (duplicated == NULL) {
data->annotations = g_slist_prepend (data->annotations,
g_strdup (alias));
}
}
return TRUE;
}
static gboolean
set_keyfile_string_array_from_json (GKeyFile *keyfile,
const char *keyfile_group,
const char *keyfile_key,
JsonArray *a,
GError **error)
{
gboolean ret = FALSE;
guint len = json_array_get_length (a);
guint i;
g_autoptr(GPtrArray) instlangs_v = g_ptr_array_new ();
for (i = 0; i < len; i++)
{
const char *elt = _rpmostree_jsonutil_array_require_string_element (a, i, error);
if (!elt)
goto out;
g_ptr_array_add (instlangs_v, (char*)elt);
}
g_key_file_set_string_list (keyfile, keyfile_group, keyfile_key,
(const char*const*)instlangs_v->pdata, instlangs_v->len);
ret = TRUE;
out:
return ret;
}
static gboolean
parse_emojione_keywords (JsonNode *node,
EmojiData *data)
{
#if 0
JsonArray *keywords;
guint i, length;
if (json_node_get_node_type (node) != JSON_NODE_ARRAY) {
g_warning ("'keywords' element is not array");
return FALSE;
}
keywords = json_node_get_array (node);
length = json_array_get_length (keywords);
for (i = 0; i < length; i++) {
const gchar *keyword = json_array_get_string_element (keywords, i);
GSList *duplicated = g_slist_find_custom (data->annotations,
keyword,
(GCompareFunc) g_strcmp0);
if (duplicated == NULL) {
data->annotations = g_slist_prepend (data->annotations,
g_strdup (keyword));
}
}
#endif
return TRUE;
}
// Check if an app is graphical by checking if it uses a known GUI interface.
// This doesn't necessarily mean that every binary uses this interfaces, but is probably true.
// https://bugs.launchpad.net/bugs/1595023
static gboolean
is_graphical (GsApp *app, GCancellable *cancellable)
{
g_autoptr(JsonObject) result = NULL;
JsonArray *plugs;
guint i;
g_autoptr(GError) error = NULL;
result = gs_snapd_get_interfaces (NULL, NULL, cancellable, &error);
if (result == NULL) {
g_warning ("Failed to check interfaces: %s", error->message);
return FALSE;
}
plugs = json_object_get_array_member (result, "plugs");
for (i = 0; i < json_array_get_length (plugs); i++) {
JsonObject *plug = json_array_get_object_element (plugs, i);
const gchar *interface;
// Only looks at the plugs for this snap
if (g_strcmp0 (json_object_get_string_member (plug, "snap"), gs_app_get_id (app)) != 0)
continue;
interface = json_object_get_string_member (plug, "interface");
if (interface == NULL)
continue;
if (g_strcmp0 (interface, "unity7") == 0 || g_strcmp0 (interface, "x11") == 0 || g_strcmp0 (interface, "mir") == 0)
return TRUE;
}
return FALSE;
}
void request_set_tag_from_ids(JsonNode * req, JsonArray * ids)
{
gint64 id =
json_array_get_length(ids) == 1 ?
json_array_get_int_element(ids, 0) : TORRENT_GET_TAG_MODE_FULL;
request_set_tag(req, id);
}
/**
* wbl_string_set_union_dependencies:
* @set: (transfer floating): a #WblStringSet
* @dependencies: a JSON object mapping property names to arrays of property
* names (or to object instances)
*
* Calculate the transitive union of the dependencies of the elements of an
* initial @set and return it as a new #WblStringSet. @dependencies is treated
* as a map of property names to dependencies; the function essentially
* calculates
* output = set ∪ ⋃_{d ϵ output} dependencies(d)
*
* Complexity: O(S * D) in the size S of @set and number D of @dependencies keys
* Returns: the transitive dependency set of @set
* Since: 0.2.0
*/
WblStringSet *
wbl_string_set_union_dependencies (WblStringSet *set,
JsonObject *dependencies)
{
WblStringSet *output = NULL;
guint old_output_size;
g_return_val_if_fail (_wbl_string_set_is_valid (set), NULL);
g_return_val_if_fail (dependencies != NULL, NULL);
output = _wbl_string_set_new ();
wbl_string_set_ref_sink (set);
do {
GHashTableIter iter;
const gchar *property_name;
old_output_size = g_hash_table_size (output->set);
g_hash_table_iter_init (&iter, set->set);
while (g_hash_table_iter_next (&iter, (gpointer *) &property_name, NULL)) {
JsonNode *dependency_value;
guint i, len;
/* Add the dependency key. */
_wbl_string_set_add (output, property_name);
/* See if there are any values associated with the
* dependency key. */
dependency_value = json_object_get_member (dependencies,
property_name);
/* Ignore schema dependencies; we only care about
* property dependencies, for which we add all
* dependent properties. */
if (dependency_value != NULL &&
JSON_NODE_HOLDS_ARRAY (dependency_value)) {
JsonArray *array;
array = json_node_get_array (dependency_value);
for (i = 0, len = json_array_get_length (array);
i < len;
i++) {
_wbl_string_set_add (output,
json_array_get_string_element (array, i));
}
}
}
} while (old_output_size != g_hash_table_size (output->set));
wbl_string_set_unref (set);
output->state |= STATE_IMMUTABLE;
return output;
}
static void
pb_got_phone_threads(PushBulletAccount *pba, JsonNode *node, gpointer user_data)
{
PurpleAccount *account = pba->account;
JsonObject *rootobj = json_node_get_object(node);
JsonObject *data = json_object_get_object_member(rootobj, "data");
JsonArray *threads = json_object_get_array_member(data, "threads");
gint i;
guint len;
gchar *device = user_data;
gint last_message_timestamp = purple_account_get_int(account, "last_message_timestamp", 0);
gint newest_phone_message_id = purple_account_get_int(account, "newest_phone_message_id", 0);
for(i = 0, len = json_array_get_length(threads); i < len; i++)
{
JsonObject *thread = json_array_get_object_element(threads, i);
const gchar *id = json_object_get_string_member(thread, "id");
JsonArray *recipients = json_object_get_array_member(thread, "recipients");
const gchar *from = NULL;
if (json_array_get_length(recipients) > 0) {
JsonObject *first_recipient = json_array_get_object_element(recipients, 0);
from = json_object_get_string_member(first_recipient, "number");
if (json_object_has_member(first_recipient, "thumbnail")) {
pb_set_base64_icon_for_buddy(json_object_get_string_member(first_recipient, "thumbnail"), purple_find_buddy(account, from));
}
}
if (from == NULL) {
continue;
}
if (json_object_has_member(thread, "latest"))
{
JsonObject *latest = json_object_get_object_member(thread, "latest");
gint64 timestamp = json_object_get_int_member(latest, "timestamp");
gint msgid = atoi(json_object_get_string_member(latest, "id"));
if (timestamp > last_message_timestamp || msgid > newest_phone_message_id) {
pb_get_phone_thread_by_id(pba, device, id, from);
}
}
}
g_free(device);
}
static void
process_results (RBPodcastSearchMiroGuide *search, JsonParser *parser)
{
JsonArray *results;
guint i;
results = json_node_get_array (json_parser_get_root (parser));
for (i = 0; i < json_array_get_length (results); i++) {
JsonObject *feed;
JsonArray *items;
RBPodcastChannel *channel;
int j;
feed = json_array_get_object_element (results, i);
channel = g_new0 (RBPodcastChannel, 1);
channel->url = g_strdup (json_object_get_string_member (feed, "url"));
channel->title = g_strdup (json_object_get_string_member (feed, "name"));
channel->author = g_strdup (json_object_get_string_member (feed, "publisher")); /* hrm */
channel->img = g_strdup (json_object_get_string_member (feed, "thumbnail_url"));
channel->is_opml = FALSE;
rb_debug ("feed %d: url %s, name \"%s\"", i, channel->url, channel->title);
items = json_object_get_array_member (feed, "item");
for (j = 0; j < json_array_get_length (items); j++) {
JsonObject *episode = json_array_get_object_element (items, j);
RBPodcastItem *item;
item = g_new0 (RBPodcastItem, 1);
item->title = g_strdup (json_object_get_string_member (episode, "name"));
item->url = g_strdup (json_object_get_string_member (episode, "url"));
item->description = g_strdup (json_object_get_string_member (episode, "description"));
item->pub_date = totem_pl_parser_parse_date (json_object_get_string_member (episode, "date"), FALSE);
item->filesize = json_object_get_int_member (episode, "size");
rb_debug ("item %d: title \"%s\", url %s", j, item->title, item->url);
channel->posts = g_list_prepend (channel->posts, item);
}
channel->posts = g_list_reverse (channel->posts);
rb_debug ("finished parsing items");
rb_podcast_search_result (RB_PODCAST_SEARCH (search), channel);
rb_podcast_parse_channel_free (channel);
}
}
static guint
json_array_size (JsonObject *object, const char *name)
{
if (!json_object_has_member (object, name))
return 0;
return json_array_get_length (json_object_get_array_member (object, name));
}
static GVariant *
parse_json_tuple (JsonNode *node,
const GVariantType *child_type,
GError **error)
{
GVariant *result = NULL;
GPtrArray *children;
GVariant *value;
JsonArray *array;
guint length;
guint i;
children = g_ptr_array_new ();
if (!check_type (node, JSON_NODE_ARRAY, 0, error))
goto out;
array = json_node_get_array (node);
length = json_array_get_length (array);
for (i = 0; i < length; i++)
{
value = NULL;
if (child_type == NULL)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Too many values in tuple/struct");
}
else
{
value = parse_json (json_array_get_element (array, i),
child_type, error);
}
if (!value)
goto out;
g_ptr_array_add (children, value);
child_type = g_variant_type_next (child_type);
}
if (child_type)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Too few values in tuple/struct");
goto out;
}
result = g_variant_new_tuple ((GVariant *const *)children->pdata,
children->len);
children->len = 0;
out:
g_ptr_array_foreach (children, (GFunc)g_variant_unref, NULL);
g_ptr_array_free (children, TRUE);
return result;
}
/*!
* Recursive function that handles converging \c JsonNode's to \c
* GNode's.
*
* \param root \c Root JsonNode to convert.
* \param node \c GNode.
* \param parsing_array \c true if handling an array, else \c false.
*/
static void
clr_oci_json_parse_aux(JsonNode* root, GNode* node, bool parsing_array) {
guint i;
g_assert (root);
g_assert (node);
if (JSON_NODE_TYPE(root) == JSON_NODE_OBJECT) {
JsonObject *object = json_node_get_object(root);
if (object) {
guint j;
guint size;
GList* keys, *key = NULL;
GList* values, *value = NULL;
size = json_object_get_size(object);
keys = json_object_get_members(object);
values = json_object_get_values(object);
node = g_node_append(node, g_node_new(NULL));
for (j = 0, key = keys, value = values; j < size; j++) {
if (key) {
node = g_node_append(node->parent, g_node_new(g_strdup(key->data)));
}
if (value) {
clr_oci_json_parse_aux(value->data, node, false);
}
key = g_list_next(key);
value = g_list_next(value);
}
if (keys) {
g_list_free(keys);
}
if (values) {
g_list_free(values);
}
}
} else if (JSON_NODE_TYPE(root) == JSON_NODE_ARRAY) {
JsonArray* array = json_node_get_array(root);
guint array_size = json_array_get_length (array);
JsonNode *array_element;
for (i = 0; i < array_size; i++) {
array_element = json_array_get_element(array, i);
clr_oci_json_parse_aux(array_element, node, true);
}
} else if (JSON_NODE_TYPE(root) == JSON_NODE_VALUE) {
node = g_node_append(node, g_node_new(clr_oci_json_string(root)));
if (parsing_array) {
node = g_node_append(node, g_node_new(NULL));
}
}
}
static int
json_object_get_member_size (JsonObject *obj,
const char *member_name)
{
if (!obj || !json_object_has_member (obj, member_name))
return 0;
return (int)json_array_get_length (json_object_get_array_member (obj, member_name));
}
static void
list_command_completed (gpointer data)
{
FrCommandUnarchiver *unar_comm = FR_COMMAND_UNARCHIVER (data);
JsonParser *parser;
GError *error = NULL;
parser = json_parser_new ();
if (json_parser_load_from_stream (parser, unar_comm->stream, NULL, &error)) {
JsonObject *root;
root = json_node_get_object (json_parser_get_root (parser));
if (json_object_get_int_member (root, "lsarFormatVersion") == LSAR_SUPPORTED_FORMAT) {
JsonArray *content;
int i;
content = json_object_get_array_member (root, "lsarContents");
for (i = 0; i < json_array_get_length (content); i++) {
JsonObject *entry;
FileData *fdata;
const char *filename;
entry = json_array_get_object_element (content, i);
fdata = file_data_new ();
fdata->size = json_object_get_int_member (entry, "XADFileSize");
fdata->modified = mktime_from_string (json_object_get_string_member (entry, "XADLastModificationDate"));
if (json_object_has_member (entry, "XADIsEncrypted"))
fdata->encrypted = json_object_get_int_member (entry, "XADIsEncrypted") == 1;
filename = json_object_get_string_member (entry, "XADFileName");
if (*filename == '/') {
fdata->full_path = g_strdup (filename);
fdata->original_path = fdata->full_path;
}
else {
fdata->full_path = g_strconcat ("/", filename, NULL);
fdata->original_path = fdata->full_path + 1;
}
fdata->link = NULL;
if (json_object_has_member (entry, "XADIsDirectory"))
fdata->dir = json_object_get_int_member (entry, "XADIsDirectory") == 1;
if (fdata->dir)
fdata->name = _g_path_get_dir_name (fdata->full_path);
else
fdata->name = g_strdup (_g_path_get_basename (fdata->full_path));
fdata->path = _g_path_remove_level (fdata->full_path);
fr_archive_add_file (FR_ARCHIVE (unar_comm), fdata);
}
}
}
g_object_unref (parser);
}
void trg_prefs_load(TrgPrefs * p)
{
TrgPrefsPrivate *priv = p->priv;
JsonParser *parser = json_parser_new();
JsonNode *root;
guint n_profiles;
JsonArray *profiles;
gboolean parsed = json_parser_load_from_file(parser, priv->file, NULL);
if (!parsed) {
trg_prefs_empty_init(p);
g_object_unref(parser);
return;
}
root = json_parser_get_root(parser);
if (root) {
priv->user = json_node_copy(root);
priv->userObj = json_node_get_object(priv->user);
}
g_object_unref(parser);
if (!root) {
trg_prefs_empty_init(p);
return;
}
if (!json_object_has_member(priv->userObj, TRG_PREFS_KEY_PROFILES)) {
profiles = json_array_new();
json_object_set_array_member(priv->userObj, TRG_PREFS_KEY_PROFILES,
profiles);
} else {
profiles = json_object_get_array_member(priv->userObj,
TRG_PREFS_KEY_PROFILES);
}
n_profiles = json_array_get_length(profiles);
if (n_profiles < 1) {
priv->profile = trg_prefs_new_profile_object();
json_array_add_object_element(profiles, priv->profile);
trg_prefs_set_int(p, TRG_PREFS_KEY_PROFILE_ID, 0,
TRG_PREFS_GLOBAL);
} else {
gint profile_id = trg_prefs_get_int(p, TRG_PREFS_KEY_PROFILE_ID,
TRG_PREFS_GLOBAL);
if (profile_id >= n_profiles)
trg_prefs_set_int(p, TRG_PREFS_KEY_PROFILE_ID, profile_id = 0,
TRG_PREFS_GLOBAL);
priv->profile =
json_array_get_object_element(profiles, profile_id);
}
}
static void onTaskReadyCallback(GObject * source, GAsyncResult * res,
gpointer userData)
{
GError *err = NULL;
//WlDictQuery *query=WL_DICT_QUERY(source);
TaskData *td = g_task_get_task_data(G_TASK(res));
gchar *responseBody = g_task_propagate_pointer(G_TASK(res), &err);
if (err) { /* Error */
if (td->cb)
td->cb(td->from, td->to, td->src, NULL, td->cbData, err);
return;
}
JsonParser *parser = json_parser_new();
if (!json_parser_load_from_data(parser, responseBody, -1, &err)) {
if (td->cb)
td->cb(td->from, td->to, td->src, NULL, td->cbData, err);
g_message("%s", responseBody);
return;
}
JsonNode *rootNode = json_parser_get_root(parser);
JsonObject *rootObj = json_node_get_object(rootNode);
const gchar *from = json_object_get_string_member(rootObj, "from");
const gchar *to = json_object_get_string_member(rootObj, "to");
if (json_object_has_member(rootObj, "error_code")) {
/* 查询出错 */
const gchar *error_msg =
json_object_get_string_member(rootObj, "error_msg");
const gchar *error_code =
json_object_get_string_member(rootObj, "error_code");
if (td->cb) {
GError *error =
g_error_new(G_IO_ERROR, atoi(error_code), "%s", error_msg);
td->cb(wl_dict_lang_get_enum(from), wl_dict_lang_get_enum(to),
json_object_get_string_member(rootObj, "query"), NULL,
td->cbData, error);
g_error_free(error);
}
g_object_unref(parser);
return;
}
JsonArray *results =
json_object_get_array_member(rootObj, "trans_result");
gint i, len = json_array_get_length(results);
for (i = 0; i < len; i++) {
JsonObject *resEle = json_array_get_object_element(results, i);
const gchar *src = json_object_get_string_member(resEle, "src");
const gchar *dst = json_object_get_string_member(resEle, "dst");
if (td->cb)
td->cb(wl_dict_lang_get_enum(from),
wl_dict_lang_get_enum(to), src, dst, td->cbData, NULL);
}
g_object_unref(parser);
}
/* This function is synchronous! Blocking once at startup seems pretty
* reasonable and allows us to avoid any complexity re. races
*/
static void
mex_queue_model_load (MexQueueModel *model)
{
JsonParser *parser;
gchar *filename;
GError *error = NULL;
JsonNode *root;
JsonArray *array;
gint i = 0;
filename = _queue_file_name ();
if (!g_file_test (filename, G_FILE_TEST_EXISTS))
{
g_free (filename);
return;
}
parser = json_parser_new ();
if (!json_parser_load_from_file (parser, filename, &error))
{
g_warning (G_STRLOC ": error populating from file: %s",
error->message);
g_clear_error (&error);
goto out;
}
root = json_parser_get_root (parser);
if (!JSON_NODE_HOLDS_ARRAY (root))
{
g_warning (G_STRLOC ": JSON data not of expected format!");
goto out;
}
array = json_node_get_array (root);
for (i = 0; i < json_array_get_length (array); i++)
{
MexContent *content;
JsonNode *node;
node = json_array_get_element (array, i);
content = (MexContent *)json_gobject_deserialize (MEX_TYPE_PROGRAM,
node);
mex_model_add_content (MEX_MODEL (model), content);
}
out:
g_free (filename);
g_object_unref (parser);
}
/* Import play list from a json object */
void plist_import_from_json( plist_t *pl, JsonArray *js_plist )
{
int num_songs = json_array_get_length(js_plist);
for ( int i = 0; i < num_songs; ++i )
{
JsonNode *js_song_node = json_array_get_element(js_plist, i);
if (!js_song_node)
continue;
if (!JSON_NODE_HOLDS_OBJECT(js_song_node))
continue;
JsonObject *js_song = json_node_get_object(js_song_node);
const char *name = js_get_string(js_song, "name", NULL);
if (!name)
continue;
song_metadata_t metadata = SONG_METADATA_EMPTY;
const char *title = js_get_string(js_song, "title", NULL);
if (title)
metadata.m_title = title;
metadata.m_len = js_get_int(js_song, "length", 0);
metadata.m_start_time = js_get_int(js_song, "start_time", -1);
metadata.m_end_time = js_get_int(js_song, "end_time", -1);
song_info_t *si = NULL;
JsonObject *js_si = js_get_obj(js_song, "song_info");
if (js_si)
{
si = si_new();
si_set_artist (si, js_get_string(js_si, "artist", ""));
si_set_name (si, js_get_string(js_si, "name", ""));
si_set_album (si, js_get_string(js_si, "album", ""));
si_set_year (si, js_get_string(js_si, "year", ""));
si_set_genre (si, js_get_string(js_si, "genre", ""));
si_set_comments (si, js_get_string(js_si, "comments", ""));
si_set_track (si, js_get_string(js_si, "track", ""));
}
bool_t is_static_info = js_get_int(js_song, "static_info", 0);
if (is_static_info)
metadata.m_song_info = si;
song_t *s = fu_is_prefixed(name) ?
song_new_from_uri(name, &metadata) :
song_new_from_file(name, &metadata);
if (s)
{
if (!is_static_info && si)
song_set_info(s, si);
plist_add_song(pl, s, -1);
}
}
}
static void
skypeweb_got_friend_profiles(SkypeWebAccount *sa, JsonNode *node, gpointer user_data)
{
JsonArray *contacts;
PurpleBuddy *buddy;
SkypeWebBuddy *sbuddy;
gint index, length;
if (node == NULL || json_node_get_node_type(node) != JSON_NODE_ARRAY)
return;
contacts = json_node_get_array(node);
length = json_array_get_length(contacts);
for(index = 0; index < length; index++)
{
JsonObject *contact = json_array_get_object_element(contacts, index);
const gchar *username = json_object_get_string_member(contact, "username");
const gchar *new_avatar;
buddy = purple_find_buddy(sa->account, username);
if (!buddy)
continue;
sbuddy = purple_buddy_get_protocol_data(buddy);
if (sbuddy == NULL) {
sbuddy = g_new0(SkypeWebBuddy, 1);
purple_buddy_set_protocol_data(buddy, sbuddy);
sbuddy->skypename = g_strdup(username);
sbuddy->sa = sa;
}
g_free(sbuddy->display_name); sbuddy->display_name = g_strdup(json_object_get_string_member(contact, "displayname"));
purple_serv_got_alias(sa->pc, username, sbuddy->display_name);
if (json_object_has_member(contact, "lastname")) {
gchar *fullname = g_strconcat(json_object_get_string_member(contact, "firstname"), " ", json_object_get_string_member(contact, "lastname"), NULL);
purple_blist_server_alias_buddy(buddy, fullname);
g_free(fullname);
} else {
purple_blist_server_alias_buddy(buddy, json_object_get_string_member(contact, "firstname"));
}
new_avatar = json_object_get_string_member(contact, "avatarUrl");
if (new_avatar && *new_avatar && (!sbuddy->avatar_url || !g_str_equal(sbuddy->avatar_url, new_avatar))) {
g_free(sbuddy->avatar_url);
sbuddy->avatar_url = g_strdup(new_avatar);
skypeweb_get_icon(buddy);
}
g_free(sbuddy->mood); sbuddy->mood = g_strdup(json_object_get_string_member(contact, "mood"));
}
}
void
cockpit_package_dump (void)
{
GHashTable *listing;
GHashTable *by_name;
GHashTableIter iter;
CockpitPackage *package;
GList *names, *l;
const gchar *prefix;
JsonArray *array;
guint i;
listing = cockpit_package_listing (NULL);
by_name = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_iter_init (&iter, listing);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&package))
g_hash_table_replace (by_name, package->name, package);
names = g_hash_table_get_keys (by_name);
names = g_list_sort (names, (GCompareFunc)strcmp);
for (l = names; l != NULL; l = g_list_next (l))
{
package = g_hash_table_lookup (by_name, l->data);
g_print ("%s: %s\n", package->name, package->directory);
if (package->checksum)
g_print (" checksum: %s\n", package->checksum);
if (package->alias)
{
prefix = " alias: ";
if (JSON_NODE_HOLDS_ARRAY (package->alias))
{
array = json_node_get_array (package->alias);
for (i = 0; i < json_array_get_length (array); i++)
{
g_print ("%s%s\n", prefix, json_array_get_string_element (array, i));
prefix = " ";
}
}
else
{
g_print ("%s%s\n", prefix, json_node_get_string (package->alias));
}
}
}
g_list_free (names);
g_hash_table_unref (by_name);
g_hash_table_unref (listing);
}
/**
* If the room has an official name, or an alias, return it
*
* @returns a string which should be freed
*/
gchar *matrix_statetable_get_room_alias(MatrixRoomStateEventTable *state_table)
{
GHashTable *tmp;
MatrixRoomEvent *event;
const gchar *tmpname = NULL;
/* start by looking for the official room name */
event = matrix_statetable_get_event(state_table, "m.room.name", "");
if(event != NULL) {
tmpname = matrix_json_object_get_string_member(
event->content, "name");
if(tmpname != NULL) {
return g_strdup(tmpname);
}
}
/* look for a canonical alias */
event = matrix_statetable_get_event(state_table, "m.room.canonical_alias",
"");
if(event != NULL) {
tmpname = matrix_json_object_get_string_member(
event->content, "alias");
if(tmpname != NULL) {
return g_strdup(tmpname);
}
}
/* look for an alias */
tmp = (GHashTable *) g_hash_table_lookup(state_table, "m.room.aliases");
if(tmp != NULL) {
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init(&iter, tmp);
while(g_hash_table_iter_next(&iter, &key, &value)) {
MatrixRoomEvent *event = value;
JsonArray *array = matrix_json_object_get_array_member(
event->content, "aliases");
if(array != NULL && json_array_get_length(array) > 0) {
tmpname = matrix_json_array_get_string_element(array, 0);
if(tmpname != NULL) {
return g_strdup(tmpname);
}
}
}
}
return NULL;
}
GHashTable *
_rpmostree_jsonutil_jsarray_strings_to_set (JsonArray *array)
{
GHashTable *ret = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free);
guint i;
guint len = json_array_get_length (array);
for (i = 0; i < len; i++)
{
const char *elt = json_array_get_string_element (array, i);
g_hash_table_add (ret, g_strdup (elt));
}
return ret;
}
/**
* @return a GList of dt_gphoto_album_ts associated to the user
*/
static GList *gphoto_get_album_list(dt_gphoto_context_t *ctx, gboolean *ok)
{
if(!ok) return NULL;
*ok = TRUE;
GList *album_list = NULL;
GList *args = NULL;
// args = _gphoto_query_add_arguments(args, "pageSize", "50"); // max for list albums
JsonObject *reply = gphoto_query_get(ctx, GOOGLE_GPHOTO "v1/albums", NULL);
if(reply == NULL) goto error;
do
{
JsonArray *jsalbums = json_object_get_array_member(reply, "albums");
for(gint i = 0; i < json_array_get_length(jsalbums); i++)
{
JsonObject *obj = json_array_get_object_element(jsalbums, i);
if(obj == NULL) continue;
dt_gphoto_album_t *album = _json_new_album(obj);
if(album)
album_list = g_list_append(album_list, album);
}
args = NULL;
// args = _gphoto_query_add_arguments(args, "pageSize", "50"); // max for list albums
if(json_object_has_member(reply, "nextPageToken"))
args = _gphoto_query_add_arguments(args, "pageToken", json_object_get_string_member(reply, "nextPageToken"));
else
break;
reply = gphoto_query_get(ctx, GOOGLE_GPHOTO "v1/albums", args);
if(reply == NULL) goto error;
} while(true);
return album_list;
error:
*ok = FALSE;
g_list_free_full(album_list, (GDestroyNotify)gphoto_album_destroy);
return NULL;
}
