gboolean torrent_has_tracker(JsonObject * t, GRegex * rx, gchar * search)
{
GList *trackers;
GList *li;
gboolean ret = FALSE;
trackers = json_array_get_elements(torrent_get_tracker_stats(t));
for (li = trackers; li; li = g_list_next(li)) {
JsonObject *tracker = json_node_get_object((JsonNode *) li->data);
const gchar *trackerAnnounce = tracker_stats_get_announce(tracker);
gchar *trackerAnnounceHost =
trg_gregex_get_first(rx, trackerAnnounce);
int cmpResult = g_strcmp0(trackerAnnounceHost, search);
g_free(trackerAnnounceHost);
if (!cmpResult) {
ret = TRUE;
break;
}
}
g_list_free(trackers);
return ret;
}
static void
trg_torrent_model_count_peers(TrgTorrentModel * model,
GtkTreeIter * iter, JsonObject * t)
{
GList *trackersList =
json_array_get_elements(torrent_get_tracker_stats(t));
gint64 seeders = 0;
gint64 leechers = 0;
gint64 downloads = 0;
GList *li;
for (li = trackersList; li; li = g_list_next(li)) {
JsonObject *tracker = json_node_get_object((JsonNode *) li->data);
seeders += tracker_stats_get_seeder_count(tracker);
leechers += tracker_stats_get_leecher_count(tracker);
downloads += tracker_stats_get_download_count(tracker);
}
g_list_free(trackersList);
gtk_list_store_set(GTK_LIST_STORE(model), iter, TORRENT_COLUMN_SEEDS,
seeders, TORRENT_COLUMN_LEECHERS, leechers,
TORRENT_COLUMN_DOWNLOADS, downloads, -1);
}
static void
progress_cb (JsonObject *result, gpointer user_data)
{
GsApp *app = user_data;
JsonArray *tasks;
GList *task_list, *l;
gint64 done = 0, total = 0;
tasks = json_object_get_array_member (result, "tasks");
task_list = json_array_get_elements (tasks);
for (l = task_list; l != NULL; l = l->next) {
JsonObject *task, *progress;
gint64 task_done, task_total;
task = json_node_get_object (l->data);
progress = json_object_get_object_member (task, "progress");
task_done = json_object_get_int_member (progress, "done");
task_total = json_object_get_int_member (progress, "total");
done += task_done;
total += task_total;
}
gs_app_set_progress (app, (guint) (100 * done / total));
g_list_free (task_list);
}
JsonNode*
cometd_msg_extract_connect(JsonNode* payload)
{
JsonNode* connect = NULL;
JsonArray* arr = json_node_get_array(payload);
GList* msgs = json_array_get_elements(arr);
gint i;
gint index = -1;
GList* item;
for (i = 0, item = msgs; item; item = g_list_next(item), ++i)
{
JsonNode* msg = item->data;
char* channel = cometd_msg_channel(msg);
if (strcmp(COMETD_CHANNEL_META_CONNECT, channel) == 0)
index = i;
free(channel);
}
if (index > -1)
{
connect = json_array_dup_element(arr, index);
json_array_remove_element(arr, index);
}
g_list_free(msgs);
return connect;
}
static void
ttrss_source_check_node_for_removal (nodePtr node, gpointer user_data)
{
JsonArray *array = (JsonArray *)user_data;
GList *iter, *elements;
gboolean found = FALSE;
if (IS_FOLDER (node)) {
// FIXME: check folders too
node_foreach_child_data (node, ttrss_source_check_node_for_removal, user_data);
} else {
elements = iter = json_array_get_elements (array);
while (iter) {
JsonNode *json_node = (JsonNode *)iter->data;
if (g_str_equal (node->subscription->source, json_get_string (json_node, "feed_url"))) {
debug1 (DEBUG_UPDATE, "node: %s", node->subscription->source);
found = TRUE;
break;
}
iter = g_list_next (iter);
}
g_list_free (elements);
if (!found)
feedlist_node_removed (node);
}
}
void trg_tree_view_setup_columns(TrgTreeView * tv)
{
TrgTreeViewPrivate *priv = TRG_TREE_VIEW_GET_PRIVATE(tv);
JsonObject *props = trg_prefs_get_tree_view_props(tv);
GList *columns, *widths, *cli, *wli;
if (!json_object_has_member(props, TRG_PREFS_KEY_TV_COLUMNS)
|| !json_object_has_member(props, TRG_PREFS_KEY_TV_WIDTHS)) {
GList *li;
for (li = priv->columns; li; li = g_list_next(li)) {
trg_column_description *desc =
(trg_column_description *) li->data;
if (desc && !(desc->flags & TRG_COLUMN_EXTRA))
trg_tree_view_add_column(tv, desc, -1);
}
return;
}
columns =
json_array_get_elements(json_object_get_array_member
(props, TRG_PREFS_KEY_TV_COLUMNS));
widths =
json_array_get_elements(json_object_get_array_member
(props, TRG_PREFS_KEY_TV_WIDTHS));
for (cli = columns, wli = widths; cli && wli;
cli = g_list_next(cli), wli = g_list_next(wli)) {
trg_column_description *desc = trg_tree_view_find_column(tv,
json_node_get_string
((JsonNode
*)
cli->
data));
if (desc) {
gint64 width = json_node_get_int((JsonNode *) wli->data);
trg_tree_view_add_column(tv, desc, width);
}
}
g_list_free(columns);
g_list_free(widths);
}
void
cometd_inbox_push(cometd_inbox* inbox, JsonNode* payload)
{
JsonArray* arr = json_node_get_array(payload);
GList* msgs = json_array_get_elements(arr);
GList* msg;
for (msg = msgs; msg; msg = g_list_next(msg))
cometd_inbox_push_msg(inbox, msg->data);
g_list_free(msgs);
}
void
gml_gtk_widget_set_file (GmlGtkWidget *gml, gchar *f)
{
JsonParser *parser = NULL;
JsonNode *node = NULL;
JsonObject *obj = NULL;
JsonArray *arr = NULL;
GError *error = NULL;
GList *l = NULL;
GList *p = NULL;
parser = json_parser_new ();
json_parser_load_from_file (parser, f, &error);
if (error) {
g_print ("Unable to parse `%s': %s\n", f, error->message);
g_error_free (error);
g_object_unref (parser);
return;
}
node = json_parser_get_root (parser);
obj = json_node_get_object (node);
l = json_object_get_members (obj);
for (p = l; p; p = p->next) {
if (!strcmp (p->data, "width")) {
gml->width = json_object_get_int_member (obj, p->data);
} else if (!strcmp (p->data, "height")) {
gml->height = json_object_get_int_member (obj, p->data);
} else if (!strcmp (p->data, "color")) {
clutter_color_from_string (&(gml->stage_color),
json_object_get_string_member (obj, p->data));
} else if (!strcmp (p->data, "elements")) {
GList *al = NULL;
GList *ap = NULL;
JsonObject *arro = NULL;
// parsing elements
arr = json_object_get_array_member (obj, p->data);
al = json_array_get_elements (arr);
for (ap = al; ap; ap = ap->next) {
arro = json_node_get_object (ap->data);
gml_gtk_widget_create_element (gml->stage, arro);
}
}
}
g_list_free (l);
g_object_unref (parser);
gtk_widget_set_size_request (gml->clutter_widget, gml->width, gml->height);
clutter_stage_set_color (CLUTTER_STAGE (gml->stage), &(gml->stage_color));
}
static void
move_local_favourites_cb(GtkInfoBar* bar,
gint res,
gpointer udata)
{
GtFavouritesManager* self = GT_FAVOURITES_MANAGER(udata);
gchar* fp = FAV_CHANNELS_FILE;
gchar* new_fp = g_strconcat(fp, ".bak", NULL);
if (res == GTK_RESPONSE_YES)
{
JsonParser* parse = json_parser_new();
JsonNode* root;
JsonArray* jarr;
gchar* fp = FAV_CHANNELS_FILE;
GError* err = NULL;
gt_channel_free_list(self->favourite_channels);
self->favourite_channels = NULL;
g_signal_emit(self, sigs[SIG_FINISHED_LOADING_FAVOURITES], 0); //TODO: Add a LOADING_FAVOURITES signal
json_parser_load_from_file(parse, fp, &err);
if (err)
{
g_warning("{GtFavouritesManager} Error move local favourite channels to twitch '%s'", err->message);
return;
}
root = json_parser_get_root(parse);
jarr = json_node_get_array(root);
for (GList* l = json_array_get_elements(jarr); l != NULL; l = l->next)
{
GtChannel* chan = GT_CHANNEL(json_gobject_deserialize(GT_TYPE_CHANNEL, l->data));
//TODO: Error handling
gt_twitch_follow_channel_async(main_app->twitch, gt_channel_get_name(chan), NULL, NULL);
g_object_unref(chan);
}
g_object_unref(parse);
g_free(fp);
gt_favourites_manager_load_from_twitch(self);
}
g_rename(fp, new_fp);
g_free(fp);
g_free(new_fp);
}
static void
reedah_item_callback (JsonNode *node, itemPtr item)
{
JsonNode *canonical, *categories;
GList *elements, *iter;
/* Determine link: path is "canonical[0]/@href" */
canonical = json_get_node (node, "canonical");
if (canonical && JSON_NODE_TYPE (canonical) == JSON_NODE_ARRAY) {
iter = elements = json_array_get_elements (json_node_get_array (canonical));
while (iter) {
const gchar *href = json_get_string ((JsonNode *)iter->data, "href");
if (href) {
item_set_source (item, href);
break;
}
iter = g_list_next (iter);
}
g_list_free (elements);
}
/* Determine read state: check for category with ".*state/com.google/read" */
categories = json_get_node (node, "categories");
if (categories && JSON_NODE_TYPE (categories) == JSON_NODE_ARRAY) {
iter = elements = json_array_get_elements (json_node_get_array (canonical));
while (iter) {
const gchar *category = json_node_get_string ((JsonNode *)iter->data);
if (category) {
item->readStatus = (strstr (category, "state\\/com.google\\/read") != NULL);
break;
}
iter = g_list_next (iter);
}
g_list_free (elements);
}
}
int
cometd_impl_process_sync(const cometd* h, JsonNode* root)
{
JsonArray* arr = json_node_get_array(root);
GList* msgs = json_array_get_elements(arr);
GList* item;
for (item = msgs; item; item = g_list_next(item))
cometd_process_msg(h, item->data);
g_list_free(msgs);
// TODO: What happens if cometd_fire_listeners blows up?
return COMETD_SUCCESS;
}
void
gt_favourites_manager_load_from_file(GtFavouritesManager* self)
{
GtFavouritesManagerPrivate* priv = gt_favourites_manager_get_instance_private(self);
JsonParser* parse = json_parser_new();
JsonNode* root;
JsonArray* jarr;
gchar* fp = FAV_CHANNELS_FILE;
GError* err = NULL;
if (!g_file_test(fp, G_FILE_TEST_EXISTS))
goto finish;
json_parser_load_from_file(parse, fp, &err);
if (err)
{
g_warning("{GtFavouritesManager} Error loading favourite channels '%s'", err->message);
goto finish;
}
root = json_parser_get_root(parse);
jarr = json_node_get_array(root);
for (GList* l = json_array_get_elements(jarr); l != NULL; l = l->next)
{
GtChannel* chan = GT_CHANNEL(json_gobject_deserialize(GT_TYPE_CHANNEL, l->data));
self->favourite_channels = g_list_append(self->favourite_channels, chan);
g_signal_handlers_block_by_func(chan, channel_favourited_cb, self);
g_object_set(chan,
"auto-update", TRUE,
"favourited", TRUE,
NULL);
gt_channel_update(chan);
g_signal_handlers_unblock_by_func(chan, channel_favourited_cb, self);
g_signal_connect(chan, "notify::updating", G_CALLBACK(oneshot_updating_cb), self);
}
finish:
g_object_unref(parse);
g_free(fp);
}
void trg_rss_model_update(TrgRssModel * model) {
TrgRssModelPrivate *priv = TRG_RSS_MODEL_GET_PRIVATE(model);
TrgPrefs *prefs = trg_client_get_prefs(priv->client);
JsonArray *feeds = trg_prefs_get_rss(prefs);
GRegex *cookie_regex;
GList *li;
if (!feeds)
return;
cookie_regex = g_regex_new("(.*):COOKIE:(.*)", 0, 0, NULL);
for (li = json_array_get_elements(feeds); li != NULL;
li = g_list_next(li)) {
JsonObject *feed = json_node_get_object((JsonNode *) li->data);
const gchar *feed_url = json_object_get_string_member(feed, "url");
const gchar *id = json_object_get_string_member(feed, "id");
feed_update *update;
GMatchInfo *match;
if (!feed_url || !id)
continue;
update = g_new0(feed_update, 1);
update->feed_id = g_strdup(id);
update->model = model;
if (g_regex_match (cookie_regex, feed_url, 0, &match)) {
update->feed_url = g_match_info_fetch(match, 1);
update->feed_cookie = g_match_info_fetch(match, 2);
g_match_info_free(match);
} else {
update->feed_url = g_strdup(feed_url);
}
async_http_request(priv->client, update->feed_url, update->feed_cookie, on_rss_receive,
update);
}
g_regex_unref(cookie_regex);
/*trg_model_remove_removed(GTK_LIST_STORE(model),
RSSCOL_UPDATESERIAL, updateSerial);*/
}
static void
ttrss_source_merge_categories (ttrssSourcePtr source, nodePtr parent, gint parentId, JsonNode *items)
{
JsonArray *array = json_node_get_array (items);
GList *iter, *elements;
elements = iter = json_array_get_elements (array);
while (iter) {
JsonNode *node = (JsonNode *)iter->data;
gint id = json_get_int (node, "bare_id");
if (id > 0) {
const gchar *type = json_get_string (node, "type");
const gchar *name = json_get_string (node, "name");
/* ignore everything without a name */
if (json_get_string (node, "name")) {
/* Process child categories */
if (type && g_str_equal (type, "category")) {
nodePtr folder;
debug2 (DEBUG_UPDATE, "TinyTinyRSS category id=%ld name=%s", id, name);
folder = ttrss_source_find_or_create_folder (name, parent);
g_hash_table_insert (source->categoryToNode, GINT_TO_POINTER (id), folder);
g_hash_table_insert (source->nodeToCategory, folder, GINT_TO_POINTER (id));
/* Process child categories ... */
if (json_get_node (node, "items"))
ttrss_source_merge_categories (source, folder, id, json_get_node (node, "items"));
/* Process child feeds */
} else {
debug3 (DEBUG_UPDATE, "TinyTinyRSS feed=%s folder=%d (%ld)", name, parentId, id);
g_hash_table_insert (source->categories, GINT_TO_POINTER (id), GINT_TO_POINTER (parentId));
}
}
}
iter = g_list_next (iter);
}
g_list_free (elements);
}
static void
twitter_user_list_build (TwitterUserList *user_list,
JsonNode *node)
{
TwitterUserListPrivate *priv = user_list->priv;
JsonArray *array;
GList *elements, *l;
GList *list = NULL;
if (!node || JSON_NODE_TYPE (node) != JSON_NODE_ARRAY)
return;
array = json_node_get_array (node);
elements = json_array_get_elements (array);
for (l = elements; l != NULL; l = l->next)
{
JsonNode *element = l->data;
if (JSON_NODE_TYPE (element) == JSON_NODE_OBJECT)
{
TwitterUser *user;
guint user_id;
user = twitter_user_new_from_node (element);
user_id = twitter_user_get_id (user);
if (user_id == 0)
{
g_object_unref (user);
continue;
}
g_hash_table_replace (priv->user_by_id,
GUINT_TO_POINTER (user_id),
g_object_ref_sink (user));
list = g_list_prepend (list, user);
}
}
priv->user_list = g_list_reverse (list);
}
void trg_prefs_del_profile(TrgPrefs * p, JsonObject * profile)
{
JsonArray *profiles = trg_prefs_get_profiles(p);
GList *profilesList = json_array_get_elements(profiles);
GList *li;
JsonNode *node;
int i = 0;
for (li = profilesList; li; li = g_list_next(li)) {
node = (JsonNode *) li->data;
if (profile == json_node_get_object(node)) {
json_array_remove_element(profiles, i);
break;
}
i++;
}
g_list_free(profilesList);
trg_prefs_profile_change_emit_signal(p);
}
void trg_prefs_set_profile(TrgPrefs * p, JsonObject * profile)
{
TrgPrefsPrivate *priv = p->priv;
GList *profiles = json_array_get_elements(trg_prefs_get_profiles(p));
gint i = 0;
GList *li;
priv->profile = profile;
for (li = profiles; li; li = g_list_next(li)) {
if (json_node_get_object((JsonNode *) li->data) == profile) {
trg_prefs_set_int(p, TRG_PREFS_KEY_PROFILE_ID, i,
TRG_PREFS_GLOBAL);
break;
}
i++;
}
g_list_free(profiles);
trg_prefs_changed_emit_signal(p, NULL);
trg_prefs_profile_change_emit_signal(p);
}
GList*
cometd_msg_supported_connection_types(JsonNode* node)
{
g_return_val_if_fail(JSON_NODE_HOLDS_OBJECT (node), NULL);
JsonObject* obj = json_node_get_object(node);
JsonArray* arr = json_object_get_array_member(obj,
"supportedConnectionTypes");
if (!arr)
return NULL;
GList *types = NULL, *ielem = NULL;
GList* items = json_array_get_elements(arr);
for (ielem = items; ielem; ielem = g_list_next(ielem))
types = g_list_prepend(types, json_node_dup_string(ielem->data));
types = g_list_reverse(types);
g_list_free(items);
return types;
}
static void
ttrss_source_subscription_list_cb (const struct updateResult * const result, gpointer user_data, guint32 flags)
{
subscriptionPtr subscription = (subscriptionPtr) user_data;
ttrssSourcePtr source = (ttrssSourcePtr) subscription->node->data;
debug1 (DEBUG_UPDATE,"ttrss_subscription_cb(): %s", result->data);
subscription->updateJob = NULL;
if (result->data && result->httpstatus == 200) {
JsonParser *parser = json_parser_new ();
if (json_parser_load_from_data (parser, result->data, -1, NULL)) {
JsonNode *content = json_get_node (json_parser_get_root (parser), "content");
JsonArray *array;
GList *iter, *elements;
/* We expect something like this:
[ {"feed_url":"http://feeds.arstechnica.com/arstechnica/everything",
"title":"Ars Technica",
"id":6,
"unread":20,
"has_icon":true,
"cat_id":0,
"last_updated":1287853210},
{"feed_url":"http://rss.slashdot.org/Slashdot/slashdot",
"title":"Slashdot",
"id":5,
"unread":33,
"has_icon":true,
"cat_id":0,
"last_updated":1287853206},
[...]
Or an error message that could look like this:
{"seq":null,"status":1,"content":{"error":"NOT_LOGGED_IN"}}
*/
if (!content || (JSON_NODE_TYPE (content) != JSON_NODE_ARRAY)) {
debug0 (DEBUG_UPDATE, "ttrss_subscription_cb(): Failed to get subscription list!");
subscription->node->available = FALSE;
return;
}
array = json_node_get_array (content);
elements = iter = json_array_get_elements (array);
/* Add all new nodes we find */
while (iter) {
JsonNode *node = (JsonNode *)iter->data;
/* ignore everything without a feed url */
if (json_get_string (node, "feed_url")) {
ttrss_source_merge_feed (source,
json_get_string (node, "feed_url"),
json_get_string (node, "title"),
json_get_int (node, "id"));
}
iter = g_list_next (iter);
}
g_list_free (elements);
/* Remove old nodes we cannot find anymore */
node_foreach_child_data (source->root, ttrss_source_check_node_for_removal, array);
/* Save new subscription tree to OPML cache file */
opml_source_export (subscription->node);
subscription->node->available = TRUE;
} else {
g_warning ("Invalid JSON returned on TinyTinyRSSS request! >>>%s<<<", result->data);
}
g_object_unref (parser);
} else {
subscription->node->available = FALSE;
debug0 (DEBUG_UPDATE, "ttrss_subscription_cb(): ERROR: failed to get TinyTinyRSS subscription list!");
}
if (!(flags & TTRSS_SOURCE_UPDATE_ONLY_LIST))
node_foreach_child_data (subscription->node, node_update_subscription, GUINT_TO_POINTER (0));
}
static void skk_map_file_load (SkkMapFile* self, const gchar* rule, const gchar* type, const gchar* name, GeeSet* included, GError** error) {
const gchar* _tmp0_;
SkkRuleMetadata* _tmp1_ = NULL;
SkkRuleMetadata* metadata;
SkkRuleMetadata* _tmp2_;
SkkRuleMetadata* _tmp5_;
const gchar* _tmp6_;
const gchar* _tmp7_;
const gchar* _tmp8_;
gchar* _tmp9_;
gchar* _tmp10_;
gchar* _tmp11_ = NULL;
gchar* _tmp12_;
gchar* filename;
const gchar* _tmp13_;
gboolean _tmp14_ = FALSE;
JsonParser* _tmp17_;
JsonParser* parser;
JsonParser* _tmp30_;
JsonNode* _tmp31_ = NULL;
JsonNode* _tmp32_;
JsonNode* root;
JsonNode* _tmp33_;
JsonNodeType _tmp34_ = 0;
JsonNode* _tmp36_;
JsonObject* _tmp37_ = NULL;
JsonObject* _tmp38_;
JsonObject* object;
JsonNode* member = NULL;
JsonObject* _tmp39_;
gboolean _tmp40_ = FALSE;
JsonObject* _tmp83_;
gboolean _tmp84_ = FALSE;
GError * _inner_error_ = NULL;
g_return_if_fail (self != NULL);
g_return_if_fail (rule != NULL);
g_return_if_fail (type != NULL);
g_return_if_fail (name != NULL);
g_return_if_fail (included != NULL);
_tmp0_ = rule;
_tmp1_ = skk_rule_find_rule (_tmp0_);
metadata = _tmp1_;
_tmp2_ = metadata;
if (_tmp2_ == NULL) {
const gchar* _tmp3_;
GError* _tmp4_;
_tmp3_ = rule;
_tmp4_ = g_error_new (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "can't find rule %s", _tmp3_);
_inner_error_ = _tmp4_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp5_ = metadata;
_tmp6_ = (*_tmp5_).base_dir;
_tmp7_ = type;
_tmp8_ = name;
_tmp9_ = g_strconcat (_tmp8_, ".json", NULL);
_tmp10_ = _tmp9_;
_tmp11_ = g_build_filename (_tmp6_, _tmp7_, _tmp10_, NULL);
_tmp12_ = _tmp11_;
_g_free0 (_tmp10_);
filename = _tmp12_;
_tmp13_ = filename;
_tmp14_ = g_file_test (_tmp13_, G_FILE_TEST_EXISTS);
if (!_tmp14_) {
const gchar* _tmp15_;
GError* _tmp16_;
_tmp15_ = filename;
_tmp16_ = g_error_new (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "no such file %s", _tmp15_);
_inner_error_ = _tmp16_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp17_ = json_parser_new ();
parser = _tmp17_;
{
JsonParser* _tmp18_;
const gchar* _tmp19_;
gboolean _tmp20_ = FALSE;
gboolean _tmp21_;
_tmp18_ = parser;
_tmp19_ = filename;
_tmp20_ = json_parser_load_from_file (_tmp18_, _tmp19_, &_inner_error_);
_tmp21_ = _tmp20_;
if (_inner_error_ != NULL) {
goto __catch28_g_error;
}
if (!_tmp21_) {
GError* _tmp22_;
_tmp22_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "");
_inner_error_ = _tmp22_;
goto __catch28_g_error;
}
}
goto __finally28;
__catch28_g_error:
{
GError* e = NULL;
const gchar* _tmp23_;
GError* _tmp24_;
const gchar* _tmp25_;
gchar* _tmp26_ = NULL;
gchar* _tmp27_;
GError* _tmp28_;
GError* _tmp29_;
e = _inner_error_;
_inner_error_ = NULL;
_tmp23_ = filename;
_tmp24_ = e;
_tmp25_ = _tmp24_->message;
_tmp26_ = g_strdup_printf ("can't load %s: %s", _tmp23_, _tmp25_);
_tmp27_ = _tmp26_;
_tmp28_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, _tmp27_);
_tmp29_ = _tmp28_;
_g_free0 (_tmp27_);
_inner_error_ = _tmp29_;
_g_error_free0 (e);
goto __finally28;
}
__finally28:
if (_inner_error_ != NULL) {
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp30_ = parser;
_tmp31_ = json_parser_get_root (_tmp30_);
_tmp32_ = __vala_JsonNode_copy0 (_tmp31_);
root = _tmp32_;
_tmp33_ = root;
_tmp34_ = json_node_get_node_type (_tmp33_);
if (_tmp34_ != JSON_NODE_OBJECT) {
GError* _tmp35_;
_tmp35_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "root element must be an object");
_inner_error_ = _tmp35_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp36_ = root;
_tmp37_ = json_node_get_object (_tmp36_);
_tmp38_ = __vala_JsonObject_copy0 (_tmp37_);
object = _tmp38_;
_tmp39_ = object;
_tmp40_ = json_object_has_member (_tmp39_, "include");
if (_tmp40_) {
JsonObject* _tmp41_;
JsonNode* _tmp42_ = NULL;
JsonNode* _tmp43_;
JsonNode* _tmp44_;
JsonNodeType _tmp45_ = 0;
JsonNode* _tmp47_;
JsonArray* _tmp48_ = NULL;
JsonArray* _tmp49_;
JsonArray* include;
JsonArray* _tmp50_;
GList* _tmp51_ = NULL;
GList* elements;
GList* _tmp52_;
_tmp41_ = object;
_tmp42_ = json_object_get_member (_tmp41_, "include");
_tmp43_ = __vala_JsonNode_copy0 (_tmp42_);
__vala_JsonNode_free0 (member);
member = _tmp43_;
_tmp44_ = member;
_tmp45_ = json_node_get_node_type (_tmp44_);
if (_tmp45_ != JSON_NODE_ARRAY) {
GError* _tmp46_;
_tmp46_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "\"include\" element must be an array");
_inner_error_ = _tmp46_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp47_ = member;
_tmp48_ = json_node_get_array (_tmp47_);
_tmp49_ = __vala_JsonArray_copy0 (_tmp48_);
include = _tmp49_;
_tmp50_ = include;
_tmp51_ = json_array_get_elements (_tmp50_);
elements = _tmp51_;
_tmp52_ = elements;
{
GList* element_collection = NULL;
GList* element_it = NULL;
element_collection = _tmp52_;
for (element_it = element_collection; element_it != NULL; element_it = element_it->next) {
JsonNode* element = NULL;
element = (JsonNode*) element_it->data;
{
JsonNode* _tmp53_;
const gchar* _tmp54_ = NULL;
gchar* _tmp55_;
gchar* parent;
GeeSet* _tmp56_;
const gchar* _tmp57_;
gboolean _tmp58_ = FALSE;
const gchar* _tmp61_;
gint _tmp62_ = 0;
gint index;
gint _tmp63_;
GeeSet* _tmp81_;
const gchar* _tmp82_;
_tmp53_ = element;
_tmp54_ = json_node_get_string (_tmp53_);
_tmp55_ = g_strdup (_tmp54_);
parent = _tmp55_;
_tmp56_ = included;
_tmp57_ = parent;
_tmp58_ = gee_collection_contains ((GeeCollection*) _tmp56_, _tmp57_);
if (_tmp58_) {
const gchar* _tmp59_;
GError* _tmp60_;
_tmp59_ = parent;
_tmp60_ = g_error_new (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "found circular include of %s", _tmp59_);
_inner_error_ = _tmp60_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp61_ = parent;
_tmp62_ = string_index_of (_tmp61_, "/", 0);
index = _tmp62_;
_tmp63_ = index;
if (_tmp63_ < 0) {
const gchar* _tmp64_;
const gchar* _tmp65_;
const gchar* _tmp66_;
GeeSet* _tmp67_;
_tmp64_ = rule;
_tmp65_ = type;
_tmp66_ = parent;
_tmp67_ = included;
skk_map_file_load (self, _tmp64_, _tmp65_, _tmp66_, _tmp67_, &_inner_error_);
if (_inner_error_ != NULL) {
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
} else {
const gchar* _tmp68_;
gint _tmp69_;
gchar* _tmp70_ = NULL;
gchar* _tmp71_;
const gchar* _tmp72_;
const gchar* _tmp73_;
gint _tmp74_;
const gchar* _tmp75_;
gint _tmp76_;
gint _tmp77_;
gchar* _tmp78_ = NULL;
gchar* _tmp79_;
GeeSet* _tmp80_;
_tmp68_ = parent;
_tmp69_ = index;
_tmp70_ = string_slice (_tmp68_, (glong) 0, (glong) _tmp69_);
_tmp71_ = _tmp70_;
_tmp72_ = type;
_tmp73_ = parent;
_tmp74_ = index;
_tmp75_ = parent;
_tmp76_ = strlen (_tmp75_);
_tmp77_ = _tmp76_;
_tmp78_ = string_slice (_tmp73_, (glong) (_tmp74_ + 1), (glong) _tmp77_);
_tmp79_ = _tmp78_;
_tmp80_ = included;
skk_map_file_load (self, _tmp71_, _tmp72_, _tmp79_, _tmp80_, &_inner_error_);
_g_free0 (_tmp79_);
_g_free0 (_tmp71_);
if (_inner_error_ != NULL) {
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
}
_tmp81_ = included;
_tmp82_ = parent;
gee_collection_add ((GeeCollection*) _tmp81_, _tmp82_);
_g_free0 (parent);
}
}
}
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
}
_tmp83_ = object;
_tmp84_ = json_object_has_member (_tmp83_, "define");
if (_tmp84_) {
JsonObject* _tmp85_;
JsonNode* _tmp86_ = NULL;
JsonNode* _tmp87_;
JsonNode* _tmp88_;
JsonNodeType _tmp89_ = 0;
JsonNode* _tmp91_;
JsonObject* _tmp92_ = NULL;
JsonObject* _tmp93_;
JsonObject* define;
JsonObject* _tmp94_;
GList* _tmp95_ = NULL;
GList* keys;
GList* _tmp96_;
_tmp85_ = object;
_tmp86_ = json_object_get_member (_tmp85_, "define");
_tmp87_ = __vala_JsonNode_copy0 (_tmp86_);
__vala_JsonNode_free0 (member);
member = _tmp87_;
_tmp88_ = member;
_tmp89_ = json_node_get_node_type (_tmp88_);
if (_tmp89_ != JSON_NODE_OBJECT) {
GError* _tmp90_;
_tmp90_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "\"define\" element must be an object");
_inner_error_ = _tmp90_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp91_ = member;
_tmp92_ = json_node_get_object (_tmp91_);
_tmp93_ = __vala_JsonObject_copy0 (_tmp92_);
define = _tmp93_;
_tmp94_ = define;
_tmp95_ = json_object_get_members (_tmp94_);
keys = _tmp95_;
_tmp96_ = keys;
{
GList* key_collection = NULL;
GList* key_it = NULL;
key_collection = _tmp96_;
for (key_it = key_collection; key_it != NULL; key_it = key_it->next) {
const gchar* key = NULL;
key = (const gchar*) key_it->data;
{
GeeMap* _tmp97_;
const gchar* _tmp98_;
gboolean _tmp99_ = FALSE;
JsonObject* _tmp104_;
const gchar* _tmp105_;
JsonNode* _tmp106_ = NULL;
JsonNode* _tmp107_;
JsonNode* _tmp108_;
JsonNodeType _tmp109_ = 0;
GeeMap* _tmp111_;
const gchar* _tmp112_;
gpointer _tmp113_ = NULL;
GeeMap* _tmp114_;
JsonNode* _tmp115_;
JsonObject* _tmp116_ = NULL;
_tmp97_ = self->priv->maps;
_tmp98_ = key;
_tmp99_ = gee_map_has_key (_tmp97_, _tmp98_);
if (!_tmp99_) {
GeeHashMap* _tmp100_;
GeeHashMap* map;
GeeMap* _tmp101_;
const gchar* _tmp102_;
GeeHashMap* _tmp103_;
_tmp100_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, json_node_get_type (), (GBoxedCopyFunc) _vala_JsonNode_copy, _vala_JsonNode_free, NULL, NULL, NULL);
map = _tmp100_;
_tmp101_ = self->priv->maps;
_tmp102_ = key;
_tmp103_ = map;
gee_map_set (_tmp101_, _tmp102_, (GeeMap*) _tmp103_);
_g_object_unref0 (map);
}
_tmp104_ = define;
_tmp105_ = key;
_tmp106_ = json_object_get_member (_tmp104_, _tmp105_);
_tmp107_ = __vala_JsonNode_copy0 (_tmp106_);
__vala_JsonNode_free0 (member);
member = _tmp107_;
_tmp108_ = member;
_tmp109_ = json_node_get_node_type (_tmp108_);
if (_tmp109_ != JSON_NODE_OBJECT) {
GError* _tmp110_;
_tmp110_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "map element must be an object");
_inner_error_ = _tmp110_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_list_free0 (keys);
__vala_JsonObject_free0 (define);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_list_free0 (keys);
__vala_JsonObject_free0 (define);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp111_ = self->priv->maps;
_tmp112_ = key;
_tmp113_ = gee_map_get (_tmp111_, _tmp112_);
_tmp114_ = (GeeMap*) _tmp113_;
_tmp115_ = member;
_tmp116_ = json_node_get_object (_tmp115_);
skk_map_file_load_map (self, _tmp114_, _tmp116_);
_g_object_unref0 (_tmp114_);
}
}
}
_g_list_free0 (keys);
__vala_JsonObject_free0 (define);
}
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
}
GList *
json_api_get_items (const gchar *json, const gchar *root, jsonApiMapping *mapping, jsonApiItemCallbackFunc callback)
{
GList *items = NULL;
JsonParser *parser = json_parser_new ();
if (json_parser_load_from_data (parser, json, -1, NULL)) {
JsonArray *array = json_node_get_array (json_get_node (json_parser_get_root (parser), root));
GList *elements = json_array_get_elements (array);
GList *iter = elements;
debug1 (DEBUG_PARSING, "JSON API: found items root node \"%s\"", root);
while (iter) {
JsonNode *node = (JsonNode *)iter->data;
itemPtr item = item_new ();
/* Parse default feeds */
item_set_id (item, json_api_get_string (node, mapping->id));
item_set_title (item, json_api_get_string (node, mapping->title));
item_set_source (item, json_api_get_string (node, mapping->link));
item->time = json_api_get_int (node, mapping->updated);
item->readStatus = json_api_get_bool (node, mapping->read);
item->flagStatus = json_api_get_bool (node, mapping->flag);
if (mapping->negateRead)
item->readStatus = !item->readStatus;
/* Handling encoded content */
const gchar *content;
gchar *xhtml;
content = json_api_get_string (node, mapping->description);
if (mapping->xhtml) {
xhtml = xhtml_extract_from_string (content, NULL);
item_set_description (item, xhtml);
xmlFree (xhtml);
} else {
item_set_description (item, content);
}
/* Optional meta data */
const gchar *tmp = json_api_get_string (node, mapping->author);
if (tmp)
item->metadata = metadata_list_append (item->metadata, "author", tmp);
items = g_list_append (items, (gpointer)item);
/* Allow optional item callback to process stuff */
if (callback)
(*callback)(node, item);
iter = g_list_next (iter);
}
g_list_free (elements);
g_object_unref (parser);
} else {
debug1 (DEBUG_PARSING, "Could not parse JSON \"%s\"", json);
}
return items;
}
void
trg_trackers_model_update(TrgTrackersModel * model,
gint64 updateSerial, JsonObject * t, gint mode)
{
TrgTrackersModelPrivate *priv = TRG_TRACKERS_MODEL_GET_PRIVATE(model);
GtkTreeIter trackIter;
JsonObject *tracker;
gint64 trackerId;
GList *trackers, *li;
const gchar *announce;
const gchar *scrape;
if (mode == TORRENT_GET_MODE_FIRST) {
gtk_list_store_clear(GTK_LIST_STORE(model));
priv->torrentId = torrent_get_id(t);
priv->accept = TRUE;
} else if (!priv->accept) {
return;
}
trackers = json_array_get_elements(torrent_get_tracker_stats(t));
for (li = trackers; li; li = g_list_next(li)) {
tracker = json_node_get_object((JsonNode *) li->data);
trackerId = tracker_stats_get_id(tracker);
announce = tracker_stats_get_announce(tracker);
scrape = tracker_stats_get_scrape(tracker);
if (mode == TORRENT_GET_MODE_FIRST
|| find_existing_model_item(GTK_TREE_MODEL(model),
TRACKERCOL_ID, trackerId,
&trackIter) == FALSE)
gtk_list_store_append(GTK_LIST_STORE(model), &trackIter);
#ifdef DEBUG
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_ICON, GTK_STOCK_NETWORK, -1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_TIER,
tracker_stats_get_tier(tracker), -1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_ANNOUNCE, announce, -1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_SCRAPE, scrape, -1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_ID, trackerId, -1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_UPDATESERIAL, updateSerial, -1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_LAST_ANNOUNCE_RESULT,
tracker_stats_get_announce_result(tracker), -1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_LAST_ANNOUNCE_TIME,
tracker_stats_get_last_announce_time(tracker),
-1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_LAST_SCRAPE_TIME,
tracker_stats_get_last_scrape_time(tracker),
-1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_HOST,
tracker_stats_get_host(tracker), -1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_LAST_ANNOUNCE_PEER_COUNT,
tracker_stats_get_last_announce_peer_count
(tracker), -1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_LEECHERCOUNT,
tracker_stats_get_leecher_count(tracker), -1);
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_SEEDERCOUNT,
tracker_stats_get_seeder_count(tracker), -1);
#else
gtk_list_store_set(GTK_LIST_STORE(model), &trackIter,
TRACKERCOL_ICON, GTK_STOCK_NETWORK,
TRACKERCOL_ID, trackerId,
TRACKERCOL_UPDATESERIAL, updateSerial,
TRACKERCOL_TIER,
tracker_stats_get_tier(tracker),
TRACKERCOL_ANNOUNCE, announce,
TRACKERCOL_SCRAPE, scrape, TRACKERCOL_HOST,
tracker_stats_get_host(tracker),
TRACKERCOL_LAST_ANNOUNCE_RESULT,
tracker_stats_get_announce_result(tracker),
TRACKERCOL_LAST_ANNOUNCE_TIME,
tracker_stats_get_last_announce_time(tracker),
TRACKERCOL_LAST_SCRAPE_TIME,
tracker_stats_get_last_scrape_time(tracker),
TRACKERCOL_LAST_ANNOUNCE_PEER_COUNT,
tracker_stats_get_last_announce_peer_count
(tracker), TRACKERCOL_LEECHERCOUNT,
tracker_stats_get_leecher_count(tracker),
TRACKERCOL_SEEDERCOUNT,
tracker_stats_get_seeder_count(tracker), -1);
#endif
}
g_list_free(trackers);
trg_model_remove_removed(GTK_LIST_STORE(model),
TRACKERCOL_UPDATESERIAL, updateSerial);
}
static void
ttrss_feed_subscription_process_update_result (subscriptionPtr subscription, const struct updateResult* const result, updateFlags flags)
{
if (result->data && result->httpstatus == 200) {
JsonParser *parser = json_parser_new ();
if (json_parser_load_from_data (parser, result->data, -1, NULL)) {
JsonArray *array = json_node_get_array (json_get_node (json_parser_get_root (parser), "content"));
GList *elements = json_array_get_elements (array);
GList *iter = elements;
GList *items = NULL;
/*
We expect to get something like this
[{"id":118,
"unread":true,
"marked":false,
"updated":1287927675,
"is_updated":false,
"title":"IBM Says New ...",
"link":"http:\/\/rss.slashdot.org\/~r\/Slashdot\/slashdot\/~3\/ALuhNKO3NV4\/story01.htm",
"feed_id":"5",
"content":"coondoggie writes ..."
},
{"id":117,
"unread":true,
"marked":false,
"updated":1287923814,
[...]
*/
while (iter) {
JsonNode *node = (JsonNode *)iter->data;
itemPtr item = item_new ();
gchar *id;
const gchar *content;
gchar *xhtml;
id = g_strdup_printf ("%" G_GINT64_FORMAT, json_get_int (node, "id"));
item_set_id (item, id);
g_free (id);
item_set_title (item, json_get_string (node, "title"));
item_set_source (item, json_get_string (node, "link"));
content = json_get_string (node, "content");
xhtml = xhtml_extract_from_string (content, NULL);
item_set_description (item, xhtml);
xmlFree (xhtml);
item->time = json_get_int (node, "updated");
if (json_get_bool (node, "unread")) {
item->readStatus = FALSE;
}
else {
item->readStatus = TRUE;
}
if (json_get_bool (node, "marked"))
item->flagStatus = TRUE;
items = g_list_append (items, (gpointer)item);
iter = g_list_next (iter);
}
g_list_free (elements);
/* merge against feed cache */
if (items) {
itemSetPtr itemSet = node_get_itemset (subscription->node);
gint newCount = itemset_merge_items (itemSet, items, TRUE /* feed valid */, FALSE /* markAsRead */);
itemlist_merge_itemset (itemSet);
itemset_free (itemSet);
feedlist_node_was_updated (subscription->node, newCount);
}
subscription->node->available = TRUE;
} else {
subscription->node->available = FALSE;
g_string_append (((feedPtr)subscription->node->data)->parseErrors, _("Could not parse JSON returned by TinyTinyRSS API!"));
}
g_object_unref (parser);
} else {
subscription->node->available = FALSE;
}
}
static void
theoldreader_subscription_cb (subscriptionPtr subscription, const struct updateResult * const result, updateFlags flags)
{
TheOldReaderSourcePtr source = (TheOldReaderSourcePtr) subscription->node->data;
debug1 (DEBUG_UPDATE,"theoldreader_subscription_cb(): %s", result->data);
subscription->updateJob = NULL;
// FIXME: the following code is very similar to ttrss!
if (result->data && result->httpstatus == 200) {
JsonParser *parser = json_parser_new ();
if (json_parser_load_from_data (parser, result->data, -1, NULL)) {
JsonArray *array = json_node_get_array (json_get_node (json_parser_get_root (parser), "subscriptions"));
GList *iter, *elements, *citer, *celements;
GSList *siter;
/* We expect something like this:
[{"id":"feed/51d49b79d1716c7b18000025",
"title":"LZone",
"categories":[{"id":"user/-/label/myfolder","label":"myfolder"}],
"sortid":"51d49b79d1716c7b18000025",
"firstitemmsec":"1371403150181",
"url":"http://lzone.de/rss.xml",
"htmlUrl":"http://lzone.de",
"iconUrl":"http://s.yeoldereader.com/system/uploads/feed/picture/5152/884a/4dce/57aa/7e00/icon_0a6a.ico"},
...
*/
elements = iter = json_array_get_elements (array);
/* Add all new nodes we find */
while (iter) {
JsonNode *categories, *node = (JsonNode *)iter->data;
nodePtr folder = NULL;
/* Check for categories, if there use first one as folder */
categories = json_get_node (node, "categories");
if (categories && JSON_NODE_TYPE (categories) == JSON_NODE_ARRAY) {
citer = celements = json_array_get_elements (json_node_get_array (categories));
while (citer) {
const gchar *label = json_get_string ((JsonNode *)citer->data, "label");
if (label) {
folder = node_source_find_or_create_folder (source->root, label, label);
/* Store category id also for folder (needed when subscribing new feeds) */
g_hash_table_insert (source->folderToCategory, g_strdup (folder->id), g_strdup (label));
break;
}
citer = g_list_next (citer);
}
g_list_free (celements);
}
/* ignore everything without a feed url */
if (json_get_string (node, "url")) {
theoldreader_source_merge_feed (source,
json_get_string (node, "url"),
json_get_string (node, "title"),
json_get_string (node, "id"),
folder);
}
iter = g_list_next (iter);
}
g_list_free (elements);
/* Remove old nodes we cannot find anymore */
node_foreach_child_data (source->root, theoldreader_source_check_node_for_removal, array);
/* Save new subscription tree to OPML cache file */
opml_source_export (subscription->node);
subscription->node->available = TRUE;
} else {
g_warning ("Invalid JSON returned on TheOldReader request! >>>%s<<<", result->data);
}
g_object_unref (parser);
} else {
subscription->node->available = FALSE;
debug0 (DEBUG_UPDATE, "theoldreader_subscription_cb(): ERROR: failed to get subscription list!");
}
if (!(flags & NODE_SOURCE_UPDATE_ONLY_LIST))
node_foreach_child_data (subscription->node, node_update_subscription, GUINT_TO_POINTER (0));
}
static void
theoldreader_subscription_cb (subscriptionPtr subscription, const struct updateResult * const result, updateFlags flags)
{
TheOldReaderSourcePtr source = (TheOldReaderSourcePtr) subscription->node->data;
debug1 (DEBUG_UPDATE,"theoldreader_subscription_cb(): %s", result->data);
// FIXME: the following code is very similar to ttrss!
if (result->data && result->httpstatus == 200) {
JsonParser *parser = json_parser_new ();
if (json_parser_load_from_data (parser, result->data, -1, NULL)) {
JsonArray *array = json_node_get_array (json_get_node (json_parser_get_root (parser), "subscriptions"));
GList *iter, *elements;
GSList *siter;
/* We expect something like this:
[{"id":"feed/51d49b79d1716c7b18000025",
"title":"LZone",
"categories":[],
"sortid":"51d49b79d1716c7b18000025",
"firstitemmsec":"1371403150181",
"url":"http://lzone.de/rss.xml",
"htmlUrl":"http://lzone.de",
"iconUrl":"http://s.yeoldereader.com/system/uploads/feed/picture/5152/884a/4dce/57aa/7e00/icon_0a6a.ico"},
...
*/
elements = iter = json_array_get_elements (array);
/* Add all new nodes we find */
while (iter) {
JsonNode *node = (JsonNode *)iter->data;
/* ignore everything without a feed url */
if (json_get_string (node, "url")) {
theoldreader_source_merge_feed (source,
json_get_string (node, "url"),
json_get_string (node, "title"),
json_get_string (node, "id"));
}
iter = g_list_next (iter);
}
g_list_free (elements);
/* Remove old nodes we cannot find anymore */
siter = source->root->children;
while (siter) {
nodePtr node = (nodePtr)siter->data;
gboolean found = FALSE;
elements = iter = json_array_get_elements (array);
while (iter) {
JsonNode *json_node = (JsonNode *)iter->data;
if (g_str_equal (node->subscription->source, json_get_string (json_node, "url"))) {
debug1 (DEBUG_UPDATE, "node: %s", node->subscription->source);
found = TRUE;
break;
}
iter = g_list_next (iter);
}
g_list_free (elements);
if (!found)
feedlist_node_removed (node);
siter = g_slist_next (siter);
}
opml_source_export (subscription->node); /* save new feeds to feed list */
subscription->node->available = TRUE;
//return;
} else {
g_warning ("Invalid JSON returned on TheOldReader request! >>>%s<<<", result->data);
}
g_object_unref (parser);
} else {
subscription->node->available = FALSE;
debug0 (DEBUG_UPDATE, "theoldreader_subscription_cb(): ERROR: failed to get subscription list!");
}
if (!(flags & THEOLDREADER_SOURCE_UPDATE_ONLY_LIST))
node_foreach_child_data (subscription->node, node_update_subscription, GUINT_TO_POINTER (0));
}
static void
google_subscription_opml_cb (subscriptionPtr subscription, const struct updateResult * const result, updateFlags flags)
{
InoreaderSourcePtr source = (InoreaderSourcePtr) subscription->node->data;
subscription->updateJob = NULL;
// FIXME: the following code is very similar to ttrss!
if (result->data && result->httpstatus == 200) {
JsonParser *parser = json_parser_new ();
if (json_parser_load_from_data (parser, result->data, -1, NULL)) {
JsonArray *array = json_node_get_array (json_get_node (json_parser_get_root (parser), "subscriptions"));
GList *iter, *elements;
GSList *siter;
/* We expect something like this:
[{"id":"feed\/http:\/\/rss.slashdot.org\/Slashdot\/slashdot",
"title":"Slashdot",
"categories":[],
"firstitemmsec":"1368112925514",
"htmlUrl":"null"},
...
Note that the data doesn't contain an URL.
We recover it from the id field.
*/
elements = iter = json_array_get_elements (array);
/* Add all new nodes we find */
while (iter) {
JsonNode *node = (JsonNode *)iter->data;
/* ignore everything without a feed url */
if (json_get_string (node, "id")) {
inoreader_source_merge_feed (source,
json_get_string (node, "id") + 5, // FIXME: Unescape string!
json_get_string (node, "title"),
json_get_string (node, "id"));
}
iter = g_list_next (iter);
}
g_list_free (elements);
/* Remove old nodes we cannot find anymore */
siter = source->root->children;
while (siter) {
nodePtr node = (nodePtr)siter->data;
gboolean found = FALSE;
elements = iter = json_array_get_elements (array);
while (iter) {
JsonNode *json_node = (JsonNode *)iter->data;
// FIXME: Compare with unescaped string
if (g_str_equal (node->subscription->source, json_get_string (json_node, "id") + 5)) {
debug1 (DEBUG_UPDATE, "node: %s", node->subscription->source);
found = TRUE;
break;
}
iter = g_list_next (iter);
}
g_list_free (elements);
if (!found)
feedlist_node_removed (node);
siter = g_slist_next (siter);
}
opml_source_export (subscription->node); /* save new feeds to feed list */
subscription->node->available = TRUE;
//return;
} else {
g_warning ("Invalid JSON returned on Inoreader feed list request! >>>%s<<<", result->data);
}
g_object_unref (parser);
} else {
subscription->node->available = FALSE;
debug0 (DEBUG_UPDATE, "inoreader_subscription_cb(): ERROR: failed to get subscription list!");
}
if (!(flags & INOREADER_SOURCE_UPDATE_ONLY_LIST))
node_foreach_child_data (subscription->node, node_update_subscription, GUINT_TO_POINTER (0));
}
static void docker_gui_get_containers (DockerGui* self, GtkListStore* listmodel) {
GtkTreeIter iter = {0};
gchar* uri = NULL;
gchar* _tmp0_ = NULL;
SoupSession* session = NULL;
SoupSession* _tmp1_ = NULL;
SoupMessage* message = NULL;
SoupMessage* _tmp2_ = NULL;
JsonParser* parser = NULL;
JsonParser* _tmp3_ = NULL;
SoupMessageBody* _tmp4_ = NULL;
SoupBuffer* _tmp5_ = NULL;
SoupBuffer* _tmp6_ = NULL;
guint8* _tmp7_ = NULL;
gint _tmp7__length1 = 0;
JsonArray* jsonContainers = NULL;
JsonNode* _tmp8_ = NULL;
JsonArray* _tmp9_ = NULL;
JsonArray* _tmp10_ = NULL;
JsonArray* _tmp11_ = NULL;
GList* _tmp12_ = NULL;
GError * _inner_error_ = NULL;
g_return_if_fail (self != NULL);
g_return_if_fail (listmodel != NULL);
_tmp0_ = g_strdup ("http://localhost:5555/containers/json");
uri = _tmp0_;
_tmp1_ = soup_session_new ();
session = _tmp1_;
_tmp2_ = soup_message_new ("GET", uri);
message = _tmp2_;
soup_session_send_message (session, message);
_tmp3_ = json_parser_new ();
parser = _tmp3_;
_tmp4_ = message->response_body;
_tmp5_ = soup_message_body_flatten (_tmp4_);
_tmp6_ = _tmp5_;
_tmp7_ = _tmp6_->data;
_tmp7__length1 = (gint) _tmp6_->length;
json_parser_load_from_data (parser, (const gchar*) _tmp7_, (gssize) (-1), &_inner_error_);
__vala_SoupBuffer_free0 (_tmp6_);
if (G_UNLIKELY (_inner_error_ != NULL)) {
_g_object_unref0 (parser);
_g_object_unref0 (message);
_g_object_unref0 (session);
_g_free0 (uri);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
_tmp8_ = json_parser_get_root (parser);
_tmp9_ = json_node_get_array (_tmp8_);
_tmp10_ = _json_array_ref0 (_tmp9_);
jsonContainers = _tmp10_;
_tmp11_ = jsonContainers;
_tmp12_ = json_array_get_elements (_tmp11_);
{
GList* c_collection = NULL;
GList* c_it = NULL;
c_collection = _tmp12_;
for (c_it = c_collection; c_it != NULL; c_it = c_it->next) {
JsonNode* _tmp13_ = NULL;
JsonNode* c = NULL;
_tmp13_ = __vala_JsonNode_copy0 ((JsonNode*) c_it->data);
c = _tmp13_;
{
JsonObject* o = NULL;
JsonNode* _tmp14_ = NULL;
JsonObject* _tmp15_ = NULL;
JsonObject* _tmp16_ = NULL;
gchar* Id = NULL;
JsonObject* _tmp17_ = NULL;
const gchar* _tmp18_ = NULL;
gchar* _tmp19_ = NULL;
gchar* Image = NULL;
JsonObject* _tmp20_ = NULL;
const gchar* _tmp21_ = NULL;
gchar* _tmp22_ = NULL;
FILE* _tmp23_ = NULL;
const gchar* _tmp24_ = NULL;
const gchar* _tmp25_ = NULL;
GtkListStore* _tmp26_ = NULL;
GtkTreeIter _tmp27_ = {0};
GtkListStore* _tmp28_ = NULL;
GtkTreeIter _tmp29_ = {0};
const gchar* _tmp30_ = NULL;
const gchar* _tmp31_ = NULL;
_tmp14_ = c;
_tmp15_ = json_node_get_object (_tmp14_);
_tmp16_ = _json_object_ref0 (_tmp15_);
o = _tmp16_;
_tmp17_ = o;
_tmp18_ = json_object_get_string_member (_tmp17_, "Id");
_tmp19_ = g_strdup (_tmp18_);
Id = _tmp19_;
_tmp20_ = o;
_tmp21_ = json_object_get_string_member (_tmp20_, "Image");
_tmp22_ = g_strdup (_tmp21_);
Image = _tmp22_;
_tmp23_ = stdout;
_tmp24_ = Id;
_tmp25_ = Image;
fprintf (_tmp23_, "%s - %s\n", _tmp24_, _tmp25_);
_tmp26_ = listmodel;
gtk_list_store_append (_tmp26_, &_tmp27_);
iter = _tmp27_;
_tmp28_ = listmodel;
_tmp29_ = iter;
_tmp30_ = Id;
_tmp31_ = Image;
gtk_list_store_set (_tmp28_, &_tmp29_, 0, _tmp30_, 1, _tmp31_, -1);
_g_free0 (Image);
_g_free0 (Id);
_json_object_unref0 (o);
__vala_JsonNode_free0 (c);
}
}
_g_list_free0 (c_collection);
}
_json_array_unref0 (jsonContainers);
_g_object_unref0 (parser);
_g_object_unref0 (message);
_g_object_unref0 (session);
_g_free0 (uri);
}
