gchar *torrent_get_full_path(JsonObject * obj)
{
const gchar *location =
json_object_get_string_member(obj, FIELD_DOWNLOAD_DIR);
const gchar *name = json_object_get_string_member(obj, FIELD_NAME);
return g_strdup_printf("%s/%s", location, name);
}
static void
_picasa_web_service_get_access_token_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
PicasaWebService *self = user_data;
GSimpleAsyncResult *result;
GError *error = NULL;
JsonNode *node;
result = _web_service_get_result (WEB_SERVICE (self));
if (picasa_web_utils_parse_json_response (msg, &node, &error)) {
JsonObject *obj;
OAuthAccount *account;
obj = json_node_get_object (node);
account = web_service_get_current_account (WEB_SERVICE (self));
if (account != NULL)
g_object_set (account,
"token", json_object_get_string_member (obj, "access_token"),
NULL);
else
_g_strset (&self->priv->access_token, json_object_get_string_member (obj, "access_token"));
}
else
g_simple_async_result_set_from_error (result, error);
g_simple_async_result_complete_in_idle (result);
}
static void
gml_gtk_widget_create_rect (ClutterActor *parent, JsonObject *obj)
{
GList *l = NULL;
GList *p = NULL;
ClutterColor color = { 0x00, 0x00, 0x00, 0xff };
ClutterActor *rect = clutter_rectangle_new ();
l = json_object_get_members (obj);
for (p = l; p; p = p->next) {
if (!strcmp (p->data, "width")) {
clutter_actor_set_width (rect, (float)json_object_get_int_member (obj, p->data));
} else if (!strcmp (p->data, "height")) {
clutter_actor_set_height (rect, (float)json_object_get_int_member (obj, p->data));
} else if (!strcmp (p->data, "x")) {
clutter_actor_set_x (rect, (float)json_object_get_int_member (obj, p->data));
} else if (!strcmp (p->data, "y")) {
clutter_actor_set_y (rect, (float)json_object_get_int_member (obj, p->data));
} else if (!strcmp (p->data, "color")) {
clutter_color_from_string (&(color), json_object_get_string_member (obj, p->data));
clutter_rectangle_set_color (CLUTTER_RECTANGLE (rect), &color);
} else if (!strcmp (p->data, "border.width")) {
clutter_rectangle_set_border_width (CLUTTER_RECTANGLE (rect), json_object_get_int_member (obj, p->data));
} else if (!strcmp (p->data, "border.color")) {
clutter_color_from_string (&(color), json_object_get_string_member (obj, p->data));
clutter_rectangle_set_border_color (CLUTTER_RECTANGLE (rect), &color);
}
}
clutter_container_add_actor (CLUTTER_CONTAINER (parent), rect);
}
static dt_gphoto_album_t *_json_new_album(JsonObject *obj)
{
// handle on writable albums (in Google Photo only albums created by the API are writeable via the API)
if(json_object_has_member(obj, "isWriteable"))
if(json_object_get_boolean_member(obj, "isWriteable"))
{
dt_gphoto_album_t *album = gphoto_album_init();
if(album == NULL) goto error;
const char *id = json_object_get_string_member(obj, "id");
const char *name = json_object_get_string_member(obj, "title");
const int size = json_object_has_member(obj, "mediaItemsCount")
? json_object_get_int_member(obj, "mediaItemsCount")
: 0;
if(id == NULL || name == NULL)
{
gphoto_album_destroy(album);
goto error;
}
album->id = g_strdup(id);
album->name = g_strdup(name);
album->size = size;
return album;
}
error:
return NULL;
}
static void
pb_process_frame(PushBulletAccount *pba, const gchar *frame)
{
JsonParser *parser = json_parser_new();
JsonNode *root;
purple_debug_info("pushbullet", "got frame data: %s\n", frame);
if (!json_parser_load_from_data(parser, frame, -1, NULL))
{
purple_debug_error("pushbullet", "Error parsing response: %s\n", frame);
return;
}
root = json_parser_get_root(parser);
if (root != NULL) {
JsonObject *message = json_node_get_object(root);
const gchar *type = json_object_get_string_member(message, "type");
if (purple_strequal(type, "tickle")) {
pb_get_everything_since(pba, purple_account_get_int(pba->account, "last_message_timestamp", 0));
} else if (purple_strequal(type, "push")) {
JsonObject *push = json_object_get_object_member(message, "push");
//{"type":"push","targets":["stream","android","ios"],"push":{"guid":"purple6e94d282","type":"messaging_extension_reply","package_name":"com.pushbullet.android","target_device_iden":"uffvytgsjAoIRwhIL6","conversation_iden":"+6421478252","message":"test2"}}
//{"type":"push","targets":["stream"],"push":{"type":"sms_changed"}}
type = json_object_get_string_member(push, "type");
if (purple_strequal(type, "sms_changed")) {
pb_get_phone_threads(pba, NULL);
}
}
}
g_object_unref(parser);
}
static void
on_web_socket_message(SoupWebsocketConnection *ws,
SoupWebsocketDataType type,
GBytes *message,
void *user_data)
{
const gchar *data;
gsize len;
data = g_bytes_get_data (message, &len);
imgflo_debug("RECV: %.*s\n", (int)len, data);
JsonParser *parser = json_parser_new();
gboolean success = json_parser_load_from_data(parser, data, len, NULL);
if (success) {
JsonNode *r = json_parser_get_root(parser);
g_assert(JSON_NODE_HOLDS_OBJECT(r));
JsonObject *root = json_node_get_object(r);
const gchar *protocol = json_object_get_string_member(root, "protocol");
const gchar *command = json_object_get_string_member(root, "command");
JsonNode *pnode = json_object_get_member(root, "payload");
JsonObject *payload = JSON_NODE_HOLDS_OBJECT(pnode) ? json_object_get_object_member(root, "payload") : NULL;
UiConnection *ui = (UiConnection *)user_data;
ui_connection_handle_message(ui, protocol, command, payload, ws);
} else {
imgflo_warning("Unable to parse WebSocket message as JSON");
}
g_object_unref(parser);
}
// 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;
}
static void
on_message (FridaScript * script,
const gchar * message,
GBytes * data,
gpointer user_data)
{
JsonParser * parser;
JsonObject * root;
const gchar * type;
parser = json_parser_new ();
json_parser_load_from_data (parser, message, -1, NULL);
root = json_node_get_object (json_parser_get_root (parser));
type = json_object_get_string_member (root, "type");
if (strcmp (type, "log") == 0)
{
const gchar * log_message;
log_message = json_object_get_string_member (root, "payload");
g_print ("%s\n", log_message);
}
else
{
g_print ("on_message: %s\n", message);
}
g_object_unref (parser);
}
END_TEST
START_TEST (test_cometd_new_publish_message)
{
cometd_conn_set_client_id(g_instance->conn, "testid");
const char* expected_channel = "/baz/bar";
JsonNode* node = cometd_json_str2node("{ \"hey\": \"now\" }");
JsonNode* message = cometd_new_publish_message(g_instance,
expected_channel,
node);
JsonObject* obj = json_node_get_object(message);
const gchar* actual_channel = json_object_get_string_member(obj,
COMETD_MSG_CHANNEL_FIELD);
ck_assert_str_eq(expected_channel, actual_channel);
JsonObject* data = json_object_get_object_member(obj,
COMETD_MSG_DATA_FIELD);
const char* value = json_object_get_string_member(data, "hey");
ck_assert_str_eq("now", value);
json_node_free(message);
json_node_free(node);
}
static void
skypeweb_got_self_details(SkypeWebAccount *sa, JsonNode *node, gpointer user_data)
{
JsonObject *userobj;
const gchar *old_alias;
const gchar *displayname = NULL;
const gchar *username;
if (node == NULL || json_node_get_node_type(node) != JSON_NODE_OBJECT)
return;
userobj = json_node_get_object(node);
username = json_object_get_string_member(userobj, "username");
g_free(sa->username); sa->username = g_strdup(username);
old_alias = purple_account_get_private_alias(sa->account);
if (!old_alias || !*old_alias) {
if (json_object_has_member(userobj, "displayname"))
displayname = json_object_get_string_member(userobj, "displayname");
if (!displayname || g_str_equal(displayname, username))
displayname = json_object_get_string_member(userobj, "firstname");
if (displayname)
purple_account_set_private_alias(sa->account, displayname);
}
if (!PURPLE_CONNECTION_IS_CONNECTED(sa->pc)) {
skypeweb_do_all_the_things(sa);
}
}
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 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);
}
}
pulseaudio_config * parse_audio_configuration (JsonObject * json_object)
{
pulseaudio_config * configuration = NULL;
gchar * server_name = NULL, * mode = NULL;
if (! json_object)
{
g_error("JSON object must not be NULL.");
}
if (! (
server_name
=
(gchar *) json_object_get_string_member(json_object, SERVER_KEY)
))
{
g_error("Missing server name in configuration.");
}
configuration = (pulseaudio_config *) g_malloc(
sizeof(pulseaudio_config)
);
if ((
mode
=
(gchar *) json_object_get_string_member(
json_object,
AUDIO_MODE_KEY
)
))
{
if (strcmp("push", mode) == 0)
{
configuration->mode = PULSEAUDIO_MODE_PUSH;
configuration->source = PA_INVALID_INDEX;
}
else if (strcmp("pull", mode) == 0)
{
configuration->mode = PULSEAUDIO_MODE_PULL;
configuration->source = json_object_get_int_member(
json_object,
SOURCE_KEY
);
}
else
{
g_error("Invalid audio mode for server '%s'", server_name);
}
}
else
{
g_error("Missing audio mode for server '%s'", server_name);
}
configuration->sink = json_object_get_int_member(
json_object,
SINK_KEY
);
return configuration;
}
static guint
install_properties(JsonOpClass *json_op_class)
{
GObjectClass *object_class = G_OBJECT_CLASS (json_op_class);
JsonObject *root = json_op_class->json_root;
guint prop = 1;
// Exported ports
if (json_object_has_member(root, "inports")) {
JsonObject *inports = json_object_get_object_member(root, "inports");
GList *inport_names = json_object_get_members(inports);
GList *l;
for (l = inport_names; l != NULL; l = l->next) {
const gchar *name = l->data;
JsonObject *conn = json_object_get_object_member(inports, name);
const gchar *proc = json_object_get_string_member(conn, "process");
const gchar *port = json_object_get_string_member(conn, "port");
JsonObject *processes = json_object_get_object_member(root, "processes");
JsonObject *p = json_object_get_object_member(processes, proc);
const gchar *component = json_object_get_string_member(p, "component");
{
GParamSpec *target_spec = NULL;
gchar *opname = component2geglop(component);
// HACK: should avoid instantiating node to determine prop
GeglNode *n = gegl_node_new();
g_assert(n);
gegl_node_set(n, "operation", opname, NULL);
target_spec = gegl_node_find_property(n, port);
if (target_spec) {
GParamSpec *spec = copy_param_spec(target_spec, name);
PropertyTarget *t = property_target_new(g_strdup(proc), g_strdup(port));
g_hash_table_insert(json_op_class->properties, GINT_TO_POINTER(prop), t);
g_object_class_install_property (object_class, prop, spec);
prop++;
}
g_object_unref(n);
g_free(opname);
}
}
g_list_free(inport_names);
}
/*
if (json_object_has_member(root, "outports")) {
JsonObject *outports = json_object_get_object_member(root, "outports");
GList *outport_names = json_object_get_members(outports);
for (int i=0; i<g_list_length(outport_names); i++) {
const gchar *name = g_list_nth_data(outport_names, i);
JsonObject *conn = json_object_get_object_member(outports, name);
const gchar *proc = json_object_get_string_member(conn, "process");
const gchar *port = json_object_get_string_member(conn, "port");
graph_add_port(self, GraphOutPort, name, proc, port);
}
}
*/
return prop-1;
}
void cb_user_identity_parse (CbUserIdentity *id,
JsonObject *user_obj)
{
id->id = json_object_get_int_member (user_obj, "id");
id->screen_name = g_strdup (json_object_get_string_member (user_obj, "screen_name"));
id->user_name = cb_utils_escape_ampersands (json_object_get_string_member (user_obj, "name"));
id->verified = json_object_get_boolean_member (user_obj, "verified");
}
static void
got_token_cb (SoupSession *session, SoupMessage *msg, gpointer user_data)
{
/* parses the authentication token from the response
*/
RBAudioscrobblerAccount *account;
JsonParser *parser;
account = RB_AUDIOSCROBBLER_ACCOUNT (user_data);
parser = json_parser_new ();
if (msg->response_body->data != NULL &&
json_parser_load_from_data (parser, msg->response_body->data, msg->response_body->length, NULL)) {
JsonObject *root_object;
root_object = json_node_get_object (json_parser_get_root (parser));
if (json_object_has_member (root_object, "token")) {
char *url;
account->priv->auth_token = g_strdup (json_object_get_string_member (root_object, "token"));
rb_debug ("granted auth token \"%s\"", account->priv->auth_token);
/* send the user to the web page using the token */
url = g_strdup_printf ("%s?api_key=%s&token=%s",
rb_audioscrobbler_service_get_auth_url (account->priv->service),
rb_audioscrobbler_service_get_api_key (account->priv->service),
account->priv->auth_token);
rb_debug ("sending user to %s", url);
gtk_show_uri (NULL, url, GDK_CURRENT_TIME, NULL);
/* add timeout which will ask for session key */
account->priv->session_key_timeout_id =
g_timeout_add_seconds (SESSION_KEY_REQUEST_TIMEOUT,
request_session_key_timeout_cb,
account);
g_free (url);
} else {
rb_debug ("error retrieving auth token: %s",
json_object_get_string_member (root_object, "message"));
/* go back to being logged out */
rb_audioscrobbler_account_logout (account);
}
} else {
/* treat as connection error */
rb_debug ("empty or invalid response retrieving auth token. treating as connection error");
cancel_session (account);
account->priv->login_status = RB_AUDIOSCROBBLER_ACCOUNT_LOGIN_STATUS_CONNECTION_ERROR;
g_signal_emit (account, rb_audioscrobbler_account_signals[LOGIN_STATUS_CHANGED],
0, account->priv->login_status);
}
g_object_unref (parser);
}
void ggp_edisc_xfer_ticket_changed(PurpleConnection *gc, const char *data)
{
ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(gc);
PurpleXfer *xfer;
JsonParser *parser;
JsonObject *ticket;
const gchar *ticket_id, *send_status;
ggp_edisc_xfer_ack_status ack_status;
gboolean is_completed;
g_return_if_fail(sdata != NULL);
parser = ggp_json_parse(data);
ticket = json_node_get_object(json_parser_get_root(parser));
ticket_id = json_object_get_string_member(ticket, "id");
ack_status = ggp_edisc_xfer_parse_ack_status(
json_object_get_string_member(ticket, "ack_status"));
send_status = json_object_get_string_member(ticket, "send_status");
if (ticket_id == NULL)
ticket_id = "";
xfer = g_hash_table_lookup(sdata->xfers_initialized, ticket_id);
if (xfer == NULL) {
purple_debug_misc("gg", "ggp_edisc_event_ticket_changed: "
"ticket %s not found, updating it...\n",
purple_debug_is_unsafe() ? ticket_id : "");
ggp_edisc_xfer_recv_ticket_got(gc, ticket_id);
g_object_unref(parser);
return;
}
is_completed = FALSE;
if (g_strcmp0("in_progress", send_status) == 0) {
/* do nothing */
} else if (g_strcmp0("completed", send_status) == 0) {
is_completed = TRUE;
} else if (g_strcmp0("expired", send_status) == 0)
ggp_edisc_xfer_error(xfer, _("File transfer expired."));
else {
purple_debug_warning("gg", "ggp_edisc_event_ticket_changed: "
"unknown send_status=%s\n", send_status);
g_object_unref(parser);
return;
}
g_object_unref(parser);
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_RECEIVE) {
if (is_completed)
ggp_edisc_xfer_recv_ticket_completed(xfer);
} else {
if (ack_status != GGP_EDISC_XFER_ACK_STATUS_UNKNOWN)
ggp_edisc_xfer_send_ticket_changed(gc, xfer, ack_status
== GGP_EDISC_XFER_ACK_STATUS_ALLOWED);
}
}
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);
}
/**
* @see https://developers.facebook.com/docs/reference/api/user/
* @return basic informations about the account
*/
static FBAccountInfo *fb_get_account_info(FBContext *ctx)
{
JsonObject *obj = fb_query_get(ctx, "me", NULL);
g_return_val_if_fail((obj != NULL), NULL);
const gchar *user_name = json_object_get_string_member(obj, "username");
const gchar *user_id = json_object_get_string_member(obj, "id");
g_return_val_if_fail(user_name != NULL && user_id != NULL, NULL);
FBAccountInfo *accountinfo = fb_account_info_init();
accountinfo->id = g_strdup(user_id);
accountinfo->username = g_strdup(user_name);
accountinfo->token = g_strdup(ctx->token);
return accountinfo;
}
static void load_account_info_fill(gchar *key, gchar *value, GSList **accountlist)
{
FBAccountInfo *info = fb_account_info_init();
info->id = g_strdup(key);
JsonParser *parser = json_parser_new();
json_parser_load_from_data(parser, value, strlen(value), NULL);
JsonNode *root = json_parser_get_root(parser);
JsonObject *obj = json_node_get_object(root);
info->token = g_strdup(json_object_get_string_member(obj, "token"));
info->username = g_strdup(json_object_get_string_member(obj, "username"));
*accountlist = g_slist_prepend(*accountlist, info);
g_object_unref(parser);
}
/* FIXME: an error exit at field i leaves fields [0..i) modified. */
bool format_from_json(
void *dest,
JsonObject *obj,
const struct field_desc *fields,
size_t num_fields,
GError **err_p)
{
for(size_t i=0; i < num_fields; i++) {
const char *name = fields[i].name;
JsonNode *node = json_object_get_member(obj, name);
if(node == NULL) {
/* not present. skip. */
continue;
}
bool null_ok = islower(fields[i].type),
is_null = json_node_is_null(node);
if(!null_ok && is_null) {
g_set_error(err_p, 0, 0,
"%s: field `%s' is null, but not allowed to",
__func__, name);
return false;
}
void *ptr = dest + fields[i].offset;
switch(tolower(fields[i].type)) {
case 'i':
*(uint64_t *)ptr = is_null ? 0 : json_object_get_int_member(obj, name);
break;
case 'b':
*(bool *)ptr = is_null ? false : json_object_get_boolean_member(obj, name);
break;
case 's':
g_free(*(char **)ptr);
*(char **)ptr = is_null ? NULL : g_strdup(json_object_get_string_member(obj, name));
break;
case 't': {
GDateTime **dt_p = ptr;
if(*dt_p != NULL) {
g_date_time_unref(*dt_p);
*dt_p = NULL;
}
*dt_p = parse_datetime(json_object_get_string_member(obj, name));
break;
}
default:
assert(false);
}
}
return true;
}
void
cb_mini_tweet_parse (CbMiniTweet *t,
JsonObject *obj)
{
GDateTime *time;
JsonObject *extended_object;
const char *tweet_text;
if (json_object_has_member (obj, "extended_tweet"))
extended_object = json_object_get_object_member (obj, "extended_tweet");
else
extended_object = obj;
time = cb_utils_parse_date (json_object_get_string_member (obj, "created_at"));
t->id = json_object_get_int_member (obj, "id");
if (json_object_has_member (extended_object, "full_text"))
tweet_text = json_object_get_string_member (extended_object, "full_text");
else
tweet_text = json_object_get_string_member (extended_object, "text");
if (json_object_has_member (extended_object, "display_text_range"))
{
/* We only remove the prefix */
guint start = (guint)json_array_get_int_element (
json_object_get_array_member (extended_object, "display_text_range"),
0);
guint i;
const char *p = tweet_text;
/* Skip ahead */
for (i = 0; i < start; i ++)
p = g_utf8_next_char (p);
t->text = g_strdup (p);
t->display_range_start = start;
}
else
{
t->text = g_strdup (tweet_text);
t->display_range_start= 0;
}
t->created_at = g_date_time_to_unix (time);
cb_user_identity_parse (&t->author, json_object_get_object_member (obj, "user"));
g_date_time_unref (time);
}
/**
* Returns a cometd_advice pointer that should be free'd by the caller.
* Returns NULL if advice cannot be found.
*
* See also: http://svn.cometd.com/trunk/bayeux/bayeux.html#toc_32
*/
cometd_advice*
cometd_msg_advice(JsonNode* node)
{
g_return_val_if_fail(JSON_NODE_HOLDS_OBJECT (node), NULL);
JsonObject* obj = json_node_get_object(node);
cometd_advice* advice = NULL;
JsonObject* advice_obj = NULL;
if (json_object_has_member(obj, COMETD_MSG_ADVICE_FIELD))
advice_obj = json_object_get_object_member(obj, COMETD_MSG_ADVICE_FIELD);
if (!advice_obj)
return NULL;
const char* reconnect = json_object_get_string_member(advice_obj,
"reconnect");
const guint64 interval = json_object_get_int_member(advice_obj, "interval");
if (reconnect || interval)
{
advice = cometd_advice_new();
advice->interval = interval;
if (strcmp("none", reconnect) == 0) {
advice->reconnect = COMETD_RECONNECT_NONE;
} else if (strcmp("handshake", reconnect) == 0) {
advice->reconnect = COMETD_RECONNECT_HANDSHAKE;
} else if (strcmp("retry", reconnect) == 0) {
advice->reconnect = COMETD_RECONNECT_RETRY;
}
}
return advice;
}
static void
handle_network_message(UiConnection *self, const gchar *command, JsonObject *payload,
SoupWebsocketConnection *ws)
{
g_return_if_fail(payload);
Network *network = NULL;
{
const gchar *graph_id = json_object_get_string_member(payload, "graph");
network = (graph_id) ? g_hash_table_lookup(self->network_map, graph_id) : NULL;
}
g_return_if_fail(network);
if (g_strcmp0(command, "start") == 0) {
// FIXME: response should be done in callback monitoring network state changes
// TODO: send timestamp, graph id
JsonObject *info = json_object_new();
send_response(ws, "network", "started", info);
g_print("\tNetwork START\n");
network_set_running(network, TRUE);
} else if (g_strcmp0(command, "stop") == 0) {
// FIXME: response should be done in callback monitoring network state changes
// TODO: send timestamp, graph id
JsonObject *info = json_object_new();
send_response(ws, "network", "stopped", info);
g_print("\tNetwork STOP\n");
network_set_running(network, FALSE);
} else {
g_printerr("Unhandled message on protocol 'network', command='%s'", command);
}
}
static void
handle_network_message(UiConnection *self, const gchar *command, JsonObject *payload,
SoupWebsocketConnection *ws)
{
g_return_if_fail(payload);
const gchar *graph_id = json_object_get_string_member(payload, "graph");
Network *network = (graph_id) ? g_hash_table_lookup(self->network_map, graph_id) : NULL;
g_return_if_fail(network);
if (g_strcmp0(command, "start") == 0) {
imgflo_info("\tNetwork START\n");
network_set_running(network, TRUE);
} else if (g_strcmp0(command, "stop") == 0) {
imgflo_info("\tNetwork STOP\n");
network_set_running(network, FALSE);
} else if (g_strcmp0(command, "edges") == 0) {
// TODO: update subscriptions
send_response(ws, "network", "edges", payload);
} else if (g_strcmp0(command, "getstatus") == 0) {
JsonObject *info = json_object_new();
json_object_set_string_member(info, "graph", graph_id);
json_object_set_boolean_member(info, "running", network_is_processing(network));
json_object_set_boolean_member(info, "started", network->running);
send_response(ws, "network", "status", info);
} else if (g_strcmp0(command, "debug") == 0) {
// Ignored, not implemented
} else {
imgflo_warning("Unhandled message on protocol 'network', command='%s'", command);
}
}
/**
* @see https://developers.facebook.com/docs/reference/api/album/
* @return the id of the uploaded photo
*/
static const gchar *fb_upload_photo_to_album(FBContext *ctx, gchar *albumid, gchar *fpath, gchar *description)
{
GString *method = g_string_new(albumid);
g_string_append(method, "/photos");
GHashTable *files = g_hash_table_new((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal);
g_hash_table_insert(files, "source", fpath);
GHashTable *args = NULL;
if (description != NULL)
{
args = g_hash_table_new((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal);
g_hash_table_insert(args, "message", description);
}
JsonObject *ref = fb_query_post(ctx, method->str, args, files);
g_string_free(method, TRUE);
g_hash_table_destroy(files);
if (args != NULL)
{
g_hash_table_destroy(args);
}
if (ref == NULL)
return NULL;
return json_object_get_string_member(ref, "id");
}
/**
* @see https://developers.facebook.com/docs/reference/api/user/
* @return the id of the newly reacted
*/
static const gchar *fb_create_album(FBContext *ctx, gchar *name, gchar *summary, FBAlbumPrivacyPolicy privacy)
{
GHashTable *args = g_hash_table_new((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal);
g_hash_table_insert(args, "name", name);
if (summary != NULL)
g_hash_table_insert(args, "message", summary);
switch (privacy)
{
case FBALBUM_PRIVACY_EVERYONE:
g_hash_table_insert(args, "privacy", "{\"value\":\"EVERYONE\"}");
break;
case FBALBUM_PRIVACY_ALL_FRIENDS:
g_hash_table_insert(args, "privacy", "{\"value\":\"ALL_FRIENDS\"}");
break;
case FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS:
g_hash_table_insert(args, "privacy", "{\"value\":\"FRIENDS_OF_FRIENDS\"}");
break;
case FBALBUM_PRIVACY_SELF:
g_hash_table_insert(args, "privacy", "{\"value\":\"SELF\"}");
break;
default:
goto error;
break;
}
JsonObject *ref = fb_query_post(ctx, "me/albums", args, NULL);
if (ref == NULL)
goto error;
g_hash_table_destroy(args);
return json_object_get_string_member(ref, "id");
error:
g_hash_table_destroy(args);
return NULL;
}
static gboolean
catch_space_load_from_json (CatchResource *resource,
JsonNode *node,
GError **error)
{
CatchSpace *space = (CatchSpace *)resource;
JsonObject *obj;
ENTRY;
g_return_val_if_fail(CATCH_IS_SPACE(space), FALSE);
g_return_val_if_fail(node != NULL, FALSE);
if (CATCH_RESOURCE_CLASS(catch_space_parent_class)->load_from_json) {
if (!CATCH_RESOURCE_CLASS(catch_space_parent_class)->
load_from_json(resource, node, error)) {
RETURN(FALSE);
}
}
if (JSON_NODE_HOLDS_OBJECT(node) &&
(obj = json_node_get_object(node))) {
if (json_object_has_member(obj, "name") &&
JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "name"))) {
catch_space_set_name(CATCH_SPACE(resource),
json_object_get_string_member(obj, "name"));
}
}
RETURN(TRUE);
}
BuilderSource *
builder_source_from_json (JsonNode *node)
{
JsonObject *object = json_node_get_object (node);
const gchar *type;
type = json_object_get_string_member (object, "type");
if (type == NULL)
g_warning ("Missing source type");
else if (strcmp (type, "archive") == 0)
return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_ARCHIVE, node);
else if (strcmp (type, "file") == 0)
return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_FILE, node);
else if (strcmp (type, "script") == 0)
return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_SCRIPT, node);
else if (strcmp (type, "shell") == 0)
return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_SHELL, node);
else if (strcmp (type, "patch") == 0)
return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_PATCH, node);
else if (strcmp (type, "git") == 0)
return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_GIT, node);
else if (strcmp (type, "bzr") == 0)
return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_BZR, node);
else
g_warning ("Unknown source type %s", type);
return NULL;
}
server_configuration * parse_server_configuration (
JsonObject * json_object
)
{
server_configuration * configuration = NULL;
if (json_object == NULL)
{
g_error("JSON object must not be NULL.");
}
configuration = (server_configuration *) g_malloc(
sizeof(server_configuration)
);
if (! (
configuration->server = g_strdup(
json_object_get_string_member(json_object, SERVER_KEY)
)
))
{
g_error("Missing server name in configuraiton.");
}
configuration->device_configuration = parse_device_configuration(
json_object
);
configuration->audio_configuration = parse_audio_configuration(
json_object
);
return configuration;
}
