HGKeeper

/* purple

* Purple is the legal property of its developers, whose names are too numerous

* to list here. Please refer to the COPYRIGHT file distributed with this

* source distribution.

* Rewritten from scratch during Google Summer of Code 2012

* by Tomek Wasilczyk (http://www.wasilczyk.pl).

* Previously implemented by:

* - Arkadiusz Miskiewicz <misiek@pld.org.pl> - first implementation (2001);

* - Bartosz Oler <bartosz@bzimage.us> - reimplemented during GSoC 2005;

* - Krzysztof Klinikowski <grommasher@gmail.com> - some parts (2009-2011).

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA

#include <glib/gi18n-lib.h>

#include <purple.h>

#include "pubdir-prpl.h"

#include "gg.h"

#include "oauth/oauth-purple.h"

#include "xml.h"

#include "utils.h"

#include "status.h"

typedef struct

{

PurpleConnection *gc;

ggp_pubdir_request_cb cb;

void *user_data;

enum

{

GGP_PUBDIR_REQUEST_TYPE_INFO,

GGP_PUBDIR_REQUEST_TYPE_SEARCH,

} type;

union

{

struct

{

uin_t uin;

} user_info;

ggp_pubdir_search_form *search_form;

} params;

} ggp_pubdir_request;

/* Searching for buddies. */

#define GGP_PUBDIR_SEARCH_TITLE _("Gadu-Gadu Public Directory")

#define GGP_PUBDIR_SEARCH_PER_PAGE 20

struct _ggp_pubdir_search_form

{

gchar *nick, *city;

ggp_pubdir_gender gender;

int offset;

int limit;

void *display_handle;

};

/* For ggp_pubdir_search_results_next, which is called by this. */

static void ggp_pubdir_search_results_display(PurpleConnection *gc,

int records_count, const ggp_pubdir_record *records, int next_offset,

void *user_data);

/******************************************************************************/

static const gchar *ggp_pubdir_provinces[] =

{

N_("Not specified"),

"dolnośląskie",

"kujawsko-pomorskie",

"lubelskie",

"lubuskie",

"łódzkie",

"małopolskie",

"mazowieckie",

"opolskie",

"podkarpackie",

"podlaskie",

"pomorskie",

"śląskie",

"świętokrzyskie",

"warmińsko-mazurskie",

"wielkopolskie",

"zachodniopomorskie",

};

static gsize ggp_pubdir_provinces_count = sizeof(ggp_pubdir_provinces)/sizeof(gchar*);

/******************************************************************************/

static void

ggp_pubdir_record_free(ggp_pubdir_record *records, int count)

{

int i;

for (i = 0; i < count; i++) {

g_free(records[i].label);

g_free(records[i].nickname);

g_free(records[i].first_name);

g_free(records[i].last_name);

g_free(records[i].city);

g_date_time_unref(records[i].birth);

}

g_free(records);

}

static void

ggp_pubdir_search_form_free(ggp_pubdir_search_form *form)

{

g_free(form->nick);

g_free(form->city);

g_free(form);

}

static void

ggp_pubdir_request_free(ggp_pubdir_request *request)

{

if (request->type == GGP_PUBDIR_REQUEST_TYPE_SEARCH)

ggp_pubdir_search_form_free(request->params.search_form);

g_free(request);

}

static void

ggp_pubdir_got_data(GObject *source, GAsyncResult *result, gpointer data) {

ggp_pubdir_request *request = data;

PurpleConnection *gc = request->gc;

GBytes *response_body = NULL;

gboolean succ = TRUE;

PurpleXmlNode *xml;

const char *xml_raw = NULL;

gsize xml_size = 0;

unsigned int status, next_offset;

int record_count, i;

ggp_pubdir_record *records;

GError *error = NULL;

response_body = soup_session_send_and_read_finish(SOUP_SESSION(source),

result, &error);

if (response_body == NULL) {

purple_debug_error("gg", "ggp_pubdir_got_data: %s", error->message);

request->cb(gc, -1, NULL, 0, request->user_data);

ggp_pubdir_request_free(request);

g_error_free(error);

return;

}

xml_raw = g_bytes_unref_to_data(response_body, &xml_size);

if (purple_debug_is_verbose() && purple_debug_is_unsafe()) {

purple_debug_misc("gg", "ggp_pubdir_got_data: xml=[%.*s]",

(int)xml_size, xml_raw);

}

xml = purple_xmlnode_from_str(xml_raw, xml_size);

if (xml == NULL) {

purple_debug_error("gg", "ggp_pubdir_got_data: "

"invalid xml\n");

request->cb(gc, -1, NULL, 0, request->user_data);

ggp_pubdir_request_free(request);

return;

}

succ &= ggp_xml_get_uint(xml, "status", &status);

if (!ggp_xml_get_uint(xml, "nextOffset", &next_offset))

next_offset = 0;

xml = purple_xmlnode_get_child(xml, "users");

if (!succ || status != 0 || !xml) {

purple_debug_error("gg", "ggp_pubdir_got_data: "

"invalid reply\n");

request->cb(gc, -1, NULL, 0, request->user_data);

ggp_pubdir_request_free(request);

return;

}

record_count = ggp_xml_child_count(xml, "user");

records = g_new0(ggp_pubdir_record, record_count);

xml = purple_xmlnode_get_child(xml, "user");

i = 0;

while (xml) {

ggp_pubdir_record *record = &records[i++];

gchar *city = NULL, *birth_s = NULL;

unsigned int gender = 0;

const gchar *uin_s;

g_assert(i <= record_count);

record->uin = ggp_str_to_uin(purple_xmlnode_get_attrib(xml, "uin"));

if (record->uin == 0)

ggp_xml_get_uint(xml, "uin", &record->uin);

if (record->uin == 0)

purple_debug_error("gg", "ggp_pubdir_got_data:"

" invalid uin\n");

uin_s = ggp_uin_to_str(record->uin);

ggp_xml_get_string(xml, "label", &record->label);

ggp_xml_get_string(xml, "nick", &record->nickname);

ggp_xml_get_string(xml, "name", &record->first_name);

ggp_xml_get_string(xml, "surname", &record->last_name);

ggp_xml_get_string(xml, "city", &city);

ggp_xml_get_string(xml, "birth", &birth_s);

ggp_xml_get_uint(xml, "gender", &gender);

ggp_xml_get_uint(xml, "age", &record->age);

ggp_xml_get_uint(xml, "province", &record->province);

record->label = ggp_free_if_equal(record->label, uin_s);

record->label = ggp_free_if_equal(record->label, "");

record->nickname = ggp_free_if_equal(record->nickname, uin_s);

record->nickname = ggp_free_if_equal(record->nickname, "");

record->first_name = ggp_free_if_equal(record->first_name, "");

record->last_name = ggp_free_if_equal(record->last_name, "");

g_clear_pointer(&record->birth, g_date_time_unref);

if (record->label) {}

else if (record->nickname)

record->label = g_strdup(record->nickname);

else if (record->first_name && record->last_name)

record->label = g_strdup_printf("%s %s",

record->first_name, record->last_name);

else if (record->first_name)

record->label = g_strdup(record->first_name);

else if (record->last_name)

record->label = g_strdup(record->last_name);

if (record->label)

g_strstrip(record->label);

if (record->nickname)

g_strstrip(record->nickname);

if (gender == 1)

record->gender = GGP_PUBDIR_GENDER_FEMALE;

else if (gender == 2)

record->gender = GGP_PUBDIR_GENDER_MALE;

else

record->gender = GGP_PUBDIR_GENDER_UNSPECIFIED;

if (city && city[0] != '\0')

record->city = g_strdup(city);

if (record->city)

g_strstrip(record->city);

if (!record->city) {

g_free(record->city);

record->city = NULL;

}

record->birth = g_date_time_new_from_iso8601(birth_s, NULL);

/*TODO: calculate age from birth */

if (purple_debug_is_verbose()) {

purple_debug_misc("gg", "ggp_pubdir_got_data: [uin:%d] "

"[label:%s] [nick:%s] [first name:%s] "

"[last name:%s] [city:%s] [gender:%d] [age:%d] "

"[birth:%lu]\n", record->uin, record->label,

record->nickname, record->first_name,

record->last_name, record->city, record->gender,

record->age, g_date_time_to_unix(record->birth));

}

g_clear_pointer(&city, g_free);

g_clear_pointer(&birth_s, g_free);

xml = purple_xmlnode_get_next_twin(xml);

}

request->cb(gc, record_count, records, next_offset, request->user_data);

ggp_pubdir_request_free(request);

ggp_pubdir_record_free(records, record_count);

}

static void

ggp_pubdir_get_info_got_token(PurpleConnection *gc, const gchar *token,

gpointer _request)

{

GGPInfo *info = NULL;

gchar *url;

SoupMessage *msg;

ggp_pubdir_request *request = _request;

PURPLE_ASSERT_CONNECTION_IS_VALID(gc);

if (!token) {

request->cb(gc, -1, NULL, 0, request->user_data);

ggp_pubdir_request_free(request);

return;

}

info = purple_connection_get_protocol_data(gc);

url = g_strdup_printf("http://api.gadu-gadu.pl/users/%u",

request->params.user_info.uin);

msg = soup_message_new("GET", url);

g_free(url);

soup_message_headers_replace(soup_message_get_request_headers(msg),

"Authorization", token);

soup_session_send_and_read_async(info->http, msg, G_PRIORITY_DEFAULT, NULL,

ggp_pubdir_got_data, request);

g_object_unref(msg);

}

void

ggp_pubdir_get_info(PurpleConnection *gc, uin_t uin, ggp_pubdir_request_cb cb,

void *user_data)

{

ggp_pubdir_request *request = g_new0(ggp_pubdir_request, 1);

gchar *url;

request->type = GGP_PUBDIR_REQUEST_TYPE_INFO;

request->gc = gc;

request->cb = cb;

request->user_data = user_data;

request->params.user_info.uin = uin;

url = g_strdup_printf("http://api.gadu-gadu.pl/users/%u", uin);

ggp_oauth_request(gc, ggp_pubdir_get_info_got_token, request, "GET", url);

g_free(url);

}

static void

ggp_pubdir_get_info_protocol_got(PurpleConnection *gc, int records_count,

const ggp_pubdir_record *records,

G_GNUC_UNUSED int next_offset, void *_uin_p)

{

uin_t uin = *((uin_t*)_uin_p);

PurpleNotifyUserInfo *info = purple_notify_user_info_new();

const ggp_pubdir_record *record = &records[0];

PurpleBuddy *buddy;

g_free(_uin_p);

if (records_count < 1) {

purple_debug_error("gg", "ggp_pubdir_get_info_protocol_got: "

"couldn't get info for %u\n", uin);

purple_notify_user_info_add_pair_plaintext(info, NULL,

_("Cannot get user information"));

purple_notify_userinfo(gc, ggp_uin_to_str(uin), info,

NULL, NULL);

purple_notify_user_info_destroy(info);

return;

}

purple_debug_info("gg", "ggp_pubdir_get_info_protocol_got: %u\n", uin);

g_assert(uin == record->uin);

g_assert(records_count == 1);

buddy = purple_blist_find_buddy(purple_connection_get_account(gc),

ggp_uin_to_str(uin));

if (buddy) {

const char *alias;

PurpleStatus *status;

gchar *status_message;

alias = purple_buddy_get_alias_only(buddy);

if (alias)

purple_notify_user_info_add_pair_plaintext(info,

_("Alias"), alias);

status = purple_presence_get_active_status(

purple_buddy_get_presence(buddy));

ggp_status_from_purplestatus(status, &status_message);

purple_notify_user_info_add_pair_plaintext(info, _("Status"),

purple_status_get_name(status));

if (status_message) {

purple_notify_user_info_add_pair_plaintext(info,

_("Message"), status_message);

}

if (record->nickname) {

purple_notify_user_info_add_pair_plaintext(info,

_("Nickname"), record->nickname);

}

if (record->first_name) {

purple_notify_user_info_add_pair_plaintext(info,

_("First name"), record->first_name);

}

if (record->last_name) {

purple_notify_user_info_add_pair_plaintext(info,

_("Last name"), record->last_name);

}

if (record->gender != GGP_PUBDIR_GENDER_UNSPECIFIED) {

purple_notify_user_info_add_pair_plaintext(info, _("Gender"),

record->gender == GGP_PUBDIR_GENDER_FEMALE ?

_("Female") : _("Male"));

}

if (record->city) {

purple_notify_user_info_add_pair_plaintext(info, _("City"),

record->city);

}

if (record->birth) {

gchar *bday = g_date_time_format(record->birth, "%Y-%m-%d");

purple_notify_user_info_add_pair_plaintext(info, _("Birthday"), bday);

g_free(bday);

} else if (record->age) {

gchar *age_s = g_strdup_printf("%d", record->age);

purple_notify_user_info_add_pair_plaintext(info, _("Age"),

age_s);

g_free(age_s);

}

purple_notify_userinfo(gc, ggp_uin_to_str(uin), info, NULL, NULL);

purple_notify_user_info_destroy(info);

}

void

ggp_pubdir_get_info_protocol(G_GNUC_UNUSED PurpleProtocolServer *protocol_server,

PurpleConnection *gc, const gchar *name)

{

uin_t uin = ggp_str_to_uin(name);

uin_t *uin_p = g_new0(uin_t, 1);

*uin_p = uin;

purple_debug_info("gg", "ggp_pubdir_get_info_protocol: %u", uin);

ggp_pubdir_get_info(gc, uin, ggp_pubdir_get_info_protocol_got, uin_p);

}

static void

ggp_pubdir_request_buddy_alias_got(PurpleConnection *gc, int records_count,

const ggp_pubdir_record *records,

G_GNUC_UNUSED int next_offset,

G_GNUC_UNUSED gpointer data)

{

uin_t uin;

const gchar *alias;

if (records_count < 0) {

purple_debug_error("gg", "ggp_pubdir_request_buddy_alias_got: "

"couldn't get info for user\n");

return;

}

uin = records[0].uin;

alias = records[0].label;

if (!alias) {

purple_debug_info("gg", "ggp_pubdir_request_buddy_alias_got: "

"public alias for %u is not available\n", uin);

return;

}

purple_debug_info("gg", "ggp_pubdir_request_buddy_alias_got: "

"public alias for %u is \"%s\"\n", uin, alias);

purple_serv_got_alias(gc, ggp_uin_to_str(uin), alias);

}

void

ggp_pubdir_request_buddy_alias(PurpleConnection *gc, PurpleBuddy *buddy)

{

uin_t uin = ggp_str_to_uin(purple_buddy_get_name(buddy));

purple_debug_info("gg", "ggp_pubdir_request_buddy_alias: %u", uin);

ggp_pubdir_get_info(gc, uin, ggp_pubdir_request_buddy_alias_got, NULL);

}

/*******************************************************************************

* Searching for buddies.

******************************************************************************/

static ggp_pubdir_search_form *

ggp_pubdir_search_form_clone(const ggp_pubdir_search_form *form)

{

ggp_pubdir_search_form *dup = g_new(ggp_pubdir_search_form, 1);

dup->nick = g_strdup(form->nick);

dup->city = g_strdup(form->city);

dup->gender = form->gender;

dup->offset = form->offset;

dup->limit = form->limit;

dup->display_handle = form->display_handle;

return dup;

}

static gchar * ggp_pubdir_search_make_query(const ggp_pubdir_search_form *form)

{

gchar *nick, *city, *gender;

gchar *query;

if (form->nick && form->nick[0] != '\0') {

gchar *nick_e = g_uri_escape_string(form->nick, NULL, FALSE);

nick = g_strdup_printf("&nick=%s", nick_e);

g_free(nick_e);

} else

nick = g_strdup("");

if (form->city && form->city[0] != '\0') {

gchar *city_e = g_uri_escape_string(form->city, NULL, FALSE);

city = g_strdup_printf("&city=%s", city_e);

g_free(city_e);

} else

city = g_strdup("");

if (form->gender != GGP_PUBDIR_GENDER_UNSPECIFIED) {

gender = g_strdup_printf("&gender=%d",

form->gender == GGP_PUBDIR_GENDER_MALE ? 2 : 1);

} else

gender = g_strdup("");

query = g_strdup_printf("/users.xml?offset=%d&limit=%d%s%s%s",

form->offset, form->limit, nick, city, gender);

g_free(nick);

g_free(city);

g_free(gender);

return query;

}

static void ggp_pubdir_search_got_token(PurpleConnection *gc,

const gchar *token, gpointer _request)

{

GGPInfo *info = NULL;

gchar *url;

SoupMessage *msg;

ggp_pubdir_request *request = _request;

gchar *query;

PURPLE_ASSERT_CONNECTION_IS_VALID(gc);

if (!token) {

request->cb(gc, -1, NULL, 0, request->user_data);

ggp_pubdir_request_free(request);

return;

}

purple_debug_misc("gg", "ggp_pubdir_search_got_token\n");

query = ggp_pubdir_search_make_query(request->params.search_form);

info = purple_connection_get_protocol_data(gc);

url = g_strdup_printf("http://api.gadu-gadu.pl%s", query);

msg = soup_message_new("GET", url);

soup_message_headers_replace(soup_message_get_request_headers(msg),

"Authorization", token);

soup_session_send_and_read_async(info->http, msg, G_PRIORITY_DEFAULT, NULL,

ggp_pubdir_got_data, request);

g_object_unref(msg);

g_free(url);

g_free(query);

}

static void

ggp_pubdir_search_execute(PurpleConnection *gc,

const ggp_pubdir_search_form *form,

ggp_pubdir_request_cb cb, void *user_data)

{

ggp_pubdir_request *request = g_new0(ggp_pubdir_request, 1);

gchar *url;

ggp_pubdir_search_form *local_form = ggp_pubdir_search_form_clone(form);

gchar *query;

request->type = GGP_PUBDIR_REQUEST_TYPE_SEARCH;

request->gc = gc;

request->cb = cb;

request->user_data = user_data;

request->params.search_form = local_form;

query = ggp_pubdir_search_make_query(form);

purple_debug_misc("gg", "ggp_pubdir_search_execute: %s", query);

url = g_strdup_printf("http://api.gadu-gadu.pl%s", query);

ggp_oauth_request(gc, ggp_pubdir_search_got_token, request, "GET", url);

g_free(query);

g_free(url);

}

static void

ggp_pubdir_search_results_new(PurpleConnection *gc, G_GNUC_UNUSED GList *row,

gpointer _form)

{

ggp_pubdir_search_form *form = _form;

ggp_pubdir_search(gc, form);

}

static void

ggp_pubdir_search_results_close(gpointer _form)

{

ggp_pubdir_search_form *form = _form;

ggp_pubdir_search_form_free(form);

}

static void

ggp_pubdir_search_results_next(PurpleConnection *gc, G_GNUC_UNUSED GList *row,

gpointer _form)

{

ggp_pubdir_search_form *form = _form;

ggp_pubdir_search_execute(gc, form, ggp_pubdir_search_results_display,

form);

}

static void

ggp_pubdir_search_results_add(PurpleConnection *gc, GList *row,

G_GNUC_UNUSED gpointer form)

{

purple_blist_request_add_buddy(purple_connection_get_account(gc),

g_list_nth_data(row, 0), NULL,

g_list_nth_data(row, 1));

}

static void

ggp_pubdir_search_results_im(PurpleConnection *gc, GList *row,

G_GNUC_UNUSED gpointer form)

{

purple_conversation_present(PURPLE_CONVERSATION(purple_im_conversation_new(

purple_connection_get_account(gc), g_list_nth_data(row, 0))));

}

static void

ggp_pubdir_search_results_info(PurpleConnection *gc, GList *row,

G_GNUC_UNUSED gpointer form)

{

ggp_pubdir_get_info_protocol(NULL, gc, g_list_nth_data(row, 0));

}

static void

ggp_pubdir_search_results_display(PurpleConnection *gc, int records_count,

const ggp_pubdir_record *records,

int next_offset, void *_form)

{

ggp_pubdir_search_form *form = _form;

PurpleNotifySearchResults *results;

int i;

purple_debug_info("gg", "ggp_pubdir_search_results_display: "

"got %d records (next offset: %d)\n",

records_count, next_offset);

if (records_count < 0 ||

(records_count == 0 && form->offset != 0))

{

purple_notify_error(gc, GGP_PUBDIR_SEARCH_TITLE,

_("Error while searching for buddies"), NULL,

purple_request_cpar_from_connection(gc));

ggp_pubdir_search_form_free(form);

return;

}

if (records_count == 0) {

purple_notify_info(gc, GGP_PUBDIR_SEARCH_TITLE,

_("No matching users found"),

_("There are no users matching your search criteria."),

purple_request_cpar_from_connection(gc));

ggp_pubdir_search_form_free(form);

return;

}

form->offset = next_offset;

results = purple_notify_searchresults_new();

purple_notify_searchresults_column_add(results,

purple_notify_searchresults_column_new(_("GG Number")));

purple_notify_searchresults_column_add(results,

purple_notify_searchresults_column_new(_("Name")));

purple_notify_searchresults_column_add(results,

purple_notify_searchresults_column_new(_("City")));

purple_notify_searchresults_column_add(results,

purple_notify_searchresults_column_new(_("Gender")));

purple_notify_searchresults_column_add(results,

purple_notify_searchresults_column_new(_("Age")));

for (i = 0; i < records_count; i++) {

GList *row = NULL;

const ggp_pubdir_record *record = &records[i];

gchar *gender = NULL, *age = NULL;

if (record->gender == GGP_PUBDIR_GENDER_MALE)

gender = g_strdup("male");

else if (record->gender == GGP_PUBDIR_GENDER_FEMALE)

gender = g_strdup("female");

if (record->age)

age = g_strdup_printf("%d", record->age);

row = g_list_append(row, g_strdup(ggp_uin_to_str(record->uin)));

row = g_list_append(row, g_strdup(record->label));

row = g_list_append(row, g_strdup(record->city));

row = g_list_append(row, gender);

row = g_list_append(row, age);

purple_notify_searchresults_row_add(results, row);

}

purple_notify_searchresults_button_add(results,

PURPLE_NOTIFY_BUTTON_ADD, ggp_pubdir_search_results_add);

purple_notify_searchresults_button_add(results,

PURPLE_NOTIFY_BUTTON_IM, ggp_pubdir_search_results_im);

purple_notify_searchresults_button_add(results,

PURPLE_NOTIFY_BUTTON_INFO, ggp_pubdir_search_results_info);

purple_notify_searchresults_button_add_labeled(results, _("New search"),

ggp_pubdir_search_results_new);

if (next_offset != 0)

purple_notify_searchresults_button_add(results,

PURPLE_NOTIFY_BUTTON_CONTINUE,

ggp_pubdir_search_results_next);

if (!form->display_handle)

form->display_handle = purple_notify_searchresults(gc,

GGP_PUBDIR_SEARCH_TITLE, _("Search results"), NULL,

results, ggp_pubdir_search_results_close, form);

else

purple_notify_searchresults_new_rows(gc, results,

form->display_handle);

g_assert(form->display_handle);

}

static void

ggp_pubdir_search_request(PurpleConnection *gc, PurpleRequestPage *page) {

ggp_pubdir_search_form *form = g_new0(ggp_pubdir_search_form, 1);

purple_debug_info("gg", "ggp_pubdir_search_request");

form->nick = g_strdup(purple_request_page_get_string(page, "name"));

form->city = g_strdup(purple_request_page_get_string(page, "city"));

form->gender =

GPOINTER_TO_INT(purple_request_page_get_choice(page, "gender"));

form->offset = 0;

form->limit = GGP_PUBDIR_SEARCH_PER_PAGE;

ggp_pubdir_search_execute(gc, form, ggp_pubdir_search_results_display,

form);

}

void

ggp_pubdir_search(PurpleConnection *gc, const ggp_pubdir_search_form *form)

{

PurpleRequestPage *page;

PurpleRequestGroup *group;

PurpleRequestField *field;

PurpleRequestFieldChoice *choice;

purple_debug_info("gg", "ggp_pubdir_search");

page = purple_request_page_new();

group = purple_request_group_new(NULL);

purple_request_page_add_group(page, group);

field = purple_request_field_string_new("name", _("Name"),

form ? form->nick : NULL, FALSE);

purple_request_group_add_field(group, field);

field = purple_request_field_string_new("city", _("City"),

form ? form->city : NULL, FALSE);

purple_request_group_add_field(group, field);

field = purple_request_field_choice_new(

"gender", _("Gender"), form ? GINT_TO_POINTER(form->gender) : NULL);

choice = PURPLE_REQUEST_FIELD_CHOICE(field);

purple_request_field_choice_add(choice, _("Male or female"), NULL);

purple_request_field_choice_add(choice, _("Male"),

GINT_TO_POINTER(GGP_PUBDIR_GENDER_MALE));

purple_request_field_choice_add(choice, _("Female"),

GINT_TO_POINTER(GGP_PUBDIR_GENDER_FEMALE));

purple_request_group_add_field(group, field);

purple_request_fields(gc, _("Find buddies"), _("Find buddies"),

_("Please, enter your search criteria below"), page,

_("OK"), G_CALLBACK(ggp_pubdir_search_request),

_("Cancel"), NULL,

purple_request_cpar_from_connection(gc), gc);

}

/*******************************************************************************

* Own profile.

******************************************************************************/

static void

ggp_pubdir_set_info_got_response(GObject *source, GAsyncResult *result,

gpointer data)

{

SoupMessage *msg = data;

GBytes *response_body = NULL;

const char *buffer = NULL;

gsize size = 0;

GError *error = NULL;

if (!SOUP_STATUS_IS_SUCCESSFUL(soup_message_get_status(msg))) {

purple_debug_error("gg", "ggp_pubdir_set_info_got_response: failed");

g_object_unref(msg);

return;

}

g_clear_object(&msg);

response_body = soup_session_send_and_read_finish(SOUP_SESSION(source),

result, &error);

if (response_body == NULL) {

purple_debug_error("gg",

"ggp_pubdir_set_info_got_response: failed: %s",

error->message);

g_error_free(error);

return;

}

buffer = g_bytes_get_data(response_body, &size);

purple_debug_info("gg", "ggp_pubdir_set_info_got_response: [%.*s]",

(int)size, buffer);

/* <result><status>0</status></result> */

/* TODO: notify about failure */

g_bytes_unref(response_body);

}

static void ggp_pubdir_set_info_got_token(PurpleConnection *gc,

const gchar *token, gpointer _record)

{

ggp_pubdir_record *record = _record;

GGPInfo *info = NULL;

SoupMessage *msg;

GBytes *body = NULL;

gchar *url;

gchar *request_data;

gchar *name, *surname, *city;

gchar *bday;

uin_t uin = record->uin;

PURPLE_ASSERT_CONNECTION_IS_VALID(gc);

if (!token) {

/* TODO: notify about failure */

ggp_pubdir_record_free(record, 1);

return;

}

info = purple_connection_get_protocol_data(gc);

name = g_uri_escape_string(record->first_name, NULL, FALSE);

surname = g_uri_escape_string(record->last_name, NULL, FALSE);

city = g_uri_escape_string(record->city, NULL, FALSE);

bday = g_date_time_format(record->birth, "%Y-%m-%d");

request_data = g_strdup_printf(

"name=%s&"

"surname=%s&"

"birth=%sT10:00:00%%2B00:00&"

"birth_priv=2&"

"gender=%d&"

"gender_priv=2&"

"city=%s&"

"province=%d",

name, surname,

bday,

record->gender,

city,

record->province);

g_free(name);

g_free(surname);

g_free(city);

g_free(bday);

if (purple_debug_is_verbose() && purple_debug_is_unsafe()) {

purple_debug_misc("gg", "ggp_pubdir_set_info_got_token: "

"query [%s]\n", request_data);

}

url = g_strdup_printf("http://api.gadu-gadu.pl/users/%u.xml", uin);

msg = soup_message_new("PUT", url);

soup_message_headers_replace(soup_message_get_request_headers(msg),

"Authorization", token);

body = g_bytes_new_take(request_data, strlen(request_data));

soup_message_set_request_body_from_bytes(msg,

"application/x-www-form-urlencoded",

body);

g_bytes_unref(body);

soup_session_send_and_read_async(info->http, msg, G_PRIORITY_DEFAULT, NULL,

ggp_pubdir_set_info_got_response, msg);

g_free(url);

ggp_pubdir_record_free(record, 1);

}

static void

ggp_pubdir_set_info_request(PurpleConnection *gc, PurpleRequestPage *page)

{

PurpleAccount *account = purple_connection_get_account(gc);

PurpleContactInfo *info = PURPLE_CONTACT_INFO(account);

gchar *url;

uin_t uin = ggp_str_to_uin(purple_contact_info_get_username(info));

ggp_pubdir_record *record = g_new0(ggp_pubdir_record, 1);

gchar *birth_s;

purple_debug_info("gg", "ggp_pubdir_set_info_request");

record->uin = uin;

record->first_name = g_strdup(purple_request_page_get_string(page,

"first_name"));

record->last_name = g_strdup(purple_request_page_get_string(page,

"last_name"));

record->gender = GPOINTER_TO_INT(purple_request_page_get_choice(page,

"gender"));

record->city = g_strdup(purple_request_page_get_string(page, "city"));

record->province = GPOINTER_TO_INT(purple_request_page_get_choice(page,

"province"));

birth_s = g_strdup_printf("%sT10:00:00+00:00",

purple_request_page_get_string(page, "birth_date"));

record->birth = g_date_time_new_from_iso8601(birth_s, NULL);

g_free(birth_s);

purple_debug_info("gg", "ggp_pubdir_set_info_request: birth [%lu][%s]",

g_date_time_to_unix(record->birth),

purple_request_page_get_string(page, "birth_date"));

url = g_strdup_printf("http://api.gadu-gadu.pl/users/%u.xml", uin);

ggp_oauth_request(gc, ggp_pubdir_set_info_got_token, record, "PUT", url);

g_free(url);

}

static void

ggp_pubdir_set_info_dialog(PurpleConnection *gc, int records_count,

const ggp_pubdir_record *records,

G_GNUC_UNUSED int next_offset,

G_GNUC_UNUSED gpointer data)

{

PurpleRequestPage *page;

PurpleRequestGroup *group;

PurpleRequestField *field;

PurpleRequestFieldChoice *choice;

gchar *bday = NULL;

gsize i;

const ggp_pubdir_record *record;

purple_debug_info("gg", "ggp_pubdir_set_info_dialog (record: %d)",

records_count);

record = (records_count == 1 ? &records[0] : NULL);

page = purple_request_page_new();

group = purple_request_group_new(NULL);

purple_request_page_add_group(page, group);

field = purple_request_field_string_new("first_name", _("First name"),

record ? record->first_name : NULL,

FALSE);

purple_request_group_add_field(group, field);

field = purple_request_field_string_new("last_name", _("Last name"),

record ? record->last_name : NULL,

FALSE);

purple_request_group_add_field(group, field);

field = purple_request_field_choice_new(

"gender", _("Gender"),

record ? GINT_TO_POINTER(record->gender)

: GGP_PUBDIR_GENDER_UNSPECIFIED);

choice = PURPLE_REQUEST_FIELD_CHOICE(field);

purple_request_field_set_required(field, TRUE);

purple_request_field_choice_add(choice, _("Male"),

GINT_TO_POINTER(GGP_PUBDIR_GENDER_MALE));

purple_request_field_choice_add(choice, _("Female"),

GINT_TO_POINTER(GGP_PUBDIR_GENDER_FEMALE));

purple_request_group_add_field(group, field);

if(record != NULL && record->birth != NULL) {

bday = g_date_time_format(record->birth, "%Y-%m-%d");

}

field = purple_request_field_string_new(

"birth_date", _("Birth Day"), bday,

FALSE);

g_free(bday);

purple_request_field_set_required(field, TRUE);

purple_request_group_add_field(group, field);

field = purple_request_field_string_new(

"city", _("City"), record ? record->city : NULL, FALSE);

purple_request_group_add_field(group, field);

/* Translators: This word is basically used to describe a Polish

province. Gadu-Gadu users outside of Poland might choose to enter some

equivalent value for themselves. For example, users in the USA might

use their state (e.g. New York). If there is an equivalent term for

your language, feel free to use it. Otherwise it's probably acceptable

to leave it changed or transliterate it into your alphabet. */

field = purple_request_field_choice_new("province", _("Voivodeship"), 0);

choice = PURPLE_REQUEST_FIELD_CHOICE(field);

purple_request_group_add_field(group, field);

for (i = 0; i < ggp_pubdir_provinces_count; i++) {

purple_request_field_choice_add(choice, ggp_pubdir_provinces[i],

GINT_TO_POINTER(i));

if (record && i == record->province) {

purple_request_field_choice_set_value(choice, GINT_TO_POINTER(i));

purple_request_field_choice_set_default_value(choice,

GINT_TO_POINTER(i));

}

purple_request_fields(gc, _("Set User Info"), _("Set User Info"), NULL,

page, _("OK"),

G_CALLBACK(ggp_pubdir_set_info_request), _("Cancel"),

NULL, purple_request_cpar_from_connection(gc), gc);

}

void

ggp_pubdir_set_info(PurpleConnection *gc)

{

PurpleAccount *account = purple_connection_get_account(gc);

PurpleContactInfo *info = PURPLE_CONTACT_INFO(account);

ggp_pubdir_get_info(gc,

ggp_str_to_uin(purple_contact_info_get_username(info)),

ggp_pubdir_set_info_dialog, NULL);

}

pidgin/pidgin