gboolean AddBuddy_cb(struct fetion_account_data *sip, struct sipmsg *msg, struct transaction *tc)
{
xmlnode *root,*item;
const gchar *uri, *name ,*group_id;
struct group_attr *g_attr;
gchar *buddy_name;
PurpleBuddy *b;
PurpleGroup *g = NULL;
struct fetion_buddy *bs;
if(msg->response != 522)
{
root = xmlnode_from_str(msg->body, msg->bodylen);
item = xmlnode_get_child(root,"contacts/buddies/buddy");
g_return_val_if_fail(item!=NULL,FALSE);
uri = xmlnode_get_attrib(item, "uri");
name = xmlnode_get_attrib(item, "local-name");
group_id = xmlnode_get_attrib(item, "buddy-lists");
buddy_name = g_strdup_printf("%s", uri);
g_attr = g_hash_table_lookup(sip->group,group_id);
if(g_attr==NULL)
{
g = purple_find_group("未分组");
if(!g)
g = purple_group_new("未分组");
}
else
{
g = purple_find_group(g_attr->name);
if(!g)
g = purple_group_new(g_attr->name);
}
b = purple_find_buddy(sip->account, buddy_name);
if(!b){
b = purple_buddy_new(sip->account, buddy_name, NULL);
}
g_free(buddy_name);
purple_blist_add_buddy(b, NULL, g, NULL);
if(name!=NULL && *name!='\0')
purple_blist_alias_buddy(b, name);
bs = g_new0(struct fetion_buddy, 1);
bs->name = g_strdup(b->name);
g_hash_table_insert(sip->buddies, bs->name, bs);
fetion_subscribe_exp(sip,bs);
}
static void
lh_migrate_build_lists(void)
{
PurpleBuddyList *blist = NULL;
PurpleBlistNode *root = NULL, *g = NULL, *c = NULL, *b = NULL;
blist = purple_get_blist();
root = blist->root;
/* walk the blist tree and build a list of the buddies and a list of
* the groups corresponding to each buddy */
/* group level */
for(g = root; g && PURPLE_BLIST_NODE_IS_GROUP(g); g = g->next)
/* contact level */
for(c = g->child; c && PURPLE_BLIST_NODE_IS_CONTACT(c); c = c->next)
/* buddy level */
for(b = c->child; b && PURPLE_BLIST_NODE_IS_BUDDY(b); b = b->next) {
PurpleGroup *tmp_group = purple_group_new(((PurpleGroup *)g)->name);
PurpleBuddy *tmp_buddy = (PurpleBuddy *)b;
/* if this buddy is on the source account then add it
* to the GLists */
if(purple_buddy_get_account(tmp_buddy) == source_account) {
PurpleBuddy *tmp_buddy_2 = purple_buddy_new(target_account,
purple_buddy_get_name(tmp_buddy),
purple_buddy_get_alias(tmp_buddy));
groups = g_list_prepend(groups, tmp_group);
buddies = g_list_prepend(buddies, tmp_buddy_2);
}
}
return;
}
bool PurpleIMContactList::addContactCbk(void * dataIn)
{
// Mutex::ScopedLock lock(PurpleIMContactList::_mutex);
Mutex::ScopedLock lock(PurpleIMContactList::_mutexContact); //VOXOX - JRT - 2009.07.14
PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn;
PurpleAccount *gAccount = getPurpleAccount( cbData->getInstance() );
PurpleGroup *gGroup = NULL;
PurpleBuddy *gBuddy = NULL;
if ((gGroup = purple_find_group(cbData->getGroupName().c_str())) == NULL)
{
gGroup = purple_group_new(cbData->getGroupName().c_str());
purple_blist_add_group(gGroup, NULL);
}
gBuddy = purple_buddy_new(gAccount, cbData->getContactId().c_str(), cbData->getContactId().c_str() );
purple_blist_add_buddy(gBuddy, NULL, gGroup, NULL);
purple_account_add_buddy(gAccount, gBuddy);
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
bool PurpleIMContactList::moveContactToGroupCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMContactList::_mutex);
PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn;
PurpleAccount* gAccount = getPurpleAccount( cbData->getInstance() );
PurpleGroup* gOldGroup = purple_find_group( cbData->getOldGroupName().c_str() );
if (gOldGroup)
{
PurpleBuddy *gBuddy = purple_find_buddy_in_group(gAccount, cbData->getContactId().c_str(), gOldGroup);
if (gBuddy)
{
PurpleGroup *gNewGroup = purple_find_group( cbData->getNewGroupName().c_str() );
if (gNewGroup)
{
gNewGroup = purple_group_new(cbData->getNewGroupName().c_str());
purple_blist_add_buddy(gBuddy, NULL, gNewGroup, NULL);
}
}
}
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
void
gevo_add_buddy(PurpleAccount *account, const char *group_name,
const char *buddy_name, const char *alias)
{
PurpleConversation *conv = NULL;
PurpleBuddy *buddy;
PurpleGroup *group;
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, buddy_name, account);
group = purple_find_group(group_name);
if (group == NULL)
{
group = purple_group_new(group_name);
purple_blist_add_group(group, NULL);
}
buddy = purple_find_buddy_in_group(account, buddy_name, group);
if (buddy == NULL)
{
buddy = purple_buddy_new(account, buddy_name, alias);
purple_blist_add_buddy(buddy, NULL, group, NULL);
}
purple_account_add_buddy(account, buddy);
if (conv != NULL)
{
purple_buddy_icon_update(purple_conv_im_get_icon(PURPLE_CONV_IM(conv)));
purple_conversation_update(conv, PURPLE_CONV_UPDATE_ADD);
}
}
static PurpleGroup *flist_get_group(const gchar *name) {
PurpleGroup *g;
if(!(g = purple_find_group(name))) {
g = purple_group_new(name);
}
return g;
}
static VALUE remove_buddy(VALUE self, VALUE buddy)
{
PurpleAccount *account = NULL;
PurpleConnection *gc = NULL;
Data_Get_Struct(self, PurpleAccount, account);
gc = purple_account_get_connection( account );
PurpleBuddy* pb = purple_find_buddy(account, RSTRING_PTR(buddy));
if (NULL == pb) {
rb_raise(rb_eRuntimeError, "Failed to remove buddy for %s : %s does not exist", purple_account_get_username(account), RSTRING_PTR(buddy));
}
char* group = _("Buddies");
PurpleGroup* grp = purple_find_group(group);
if (!grp)
{
grp = purple_group_new(group);
purple_blist_add_group(grp, NULL);
}
purple_blist_remove_buddy(pb);
purple_account_remove_buddy(account, pb, grp);
serv_rem_permit( gc, RSTRING_PTR( buddy ) );
return Qtrue;
}
void QuetzalAccount::load(Config cfg)
{
cfg.beginGroup(QLatin1String("general"));
QByteArray password = cfg.value(QLatin1String("passwd"), QString(), Config::Crypted).toUtf8();
if (!password.isEmpty()) {
purple_account_set_password(m_account, password.constData());
purple_account_set_remember_password(m_account, true);
}
purple_account_set_alias(m_account, cfg.value(QLatin1String("alias"),
QString()).toUtf8().constData());
purple_account_set_user_info(m_account, cfg.value(QLatin1String("userInfo"),
QString()).toUtf8().constData());
QMapIterator<QString, QVariant> it(cfg.value(QLatin1String("quetzal_settings")).toMap());
while (it.hasNext()) {
it.next();
QByteArray key = it.key().toUtf8();
QVariant::Type type = it.value().type();
if (type == QVariant::Bool) {
purple_account_set_bool(m_account, key.constData(), it.value().toBool());
} else if (type == QVariant::Int || type == QVariant::UInt
|| type == QVariant::LongLong || type == QVariant::ULongLong) {
purple_account_set_int(m_account, key.constData(), it.value().toInt());
} else {
purple_account_set_string(m_account, key.constData(), it.value().toString().toUtf8());
}
}
cfg.endGroup();
RosterStorage::instance()->load(this);
int size = cfg.beginArray(QLatin1String("chats"));
QString name = QLatin1String("name");
QString recent = QLatin1String("recent");
QString data = QLatin1String("data");
for (int i = 0; i < size; i++) {
cfg.setArrayIndex(i);
QByteArray alias = cfg.value(name, QString()).toUtf8();
PurpleGroup *group = NULL;
if (cfg.value(recent, false)) {
group = purple_find_group("Recent");
if (!group) {
group = purple_group_new("Recent");
purple_blist_add_group(group, NULL);
}
}
GHashTable *comps = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
QMapIterator<QString, QVariant> it(cfg.value(data).toMap());
while (it.hasNext()) {
it.next();
QByteArray key = it.key().toUtf8();
QByteArray value = it.value().toString().toUtf8();
g_hash_table_insert(comps, g_strdup(key.constData()), g_strdup(value.constData()));
}
PurpleChat *pc = purple_chat_new(m_account, alias.constData(), comps);
purple_blist_add_chat(pc, NULL, NULL);
}
_purple_buddy_icons_blist_loaded_cb();
}
PurpleGroup *tgp_blist_group_init (const char *name) {
PurpleGroup *grp = purple_find_group (name);
if (grp == NULL) {
grp = purple_group_new (name);
purple_blist_add_group (grp, NULL);
}
return grp;
}
void
fb_got_groups(FacebookAccount *fba, const gchar *data, gsize data_len, gpointer user_data)
{
// look for /home.php?sk=group_ ...
gchar **splits;
gint i;
PurpleGroup *group;
splits = g_strsplit(data, "<a href=\\\"\\/home.php?sk=group_", 0);
if (!splits || !splits[0])
{
g_strfreev(splits);
return;
}
group = purple_find_group(DEFAULT_GROUP_NAME);
if (!group)
{
group = purple_group_new(DEFAULT_GROUP_NAME);
purple_blist_add_group(group, NULL);
}
for(i = 1; splits[i]; i++)
{
gchar *eos;
eos = strchr(splits[i], '\\');
if (eos != NULL)
{
*eos = '\0';
purple_debug_info("facebook", "searching for %s\n", splits[i]);
if (!purple_blist_find_chat(fba->account, splits[i]))
{
gchar *alias = NULL;
if (eos[1] == '"' && eos[2] == '>')
{
purple_debug_info("facebook", "searching for alias\n");
gchar *eoa = strchr(&eos[3], '<');
if (eoa)
{
*eoa = '\0';
alias = &eos[3];
purple_debug_info("facebook", "found chat alias %s\n", alias);
}
}
purple_debug_info("facebook", "adding chat %s to buddy list...\n", splits[i]);
// Add the group chat to the buddy list
GHashTable *components = fb_chat_info_defaults(fba->pc, splits[i]);
PurpleChat *chat = purple_chat_new(fba->account, alias, components);
purple_blist_add_chat(chat, group, NULL);
purple_debug_info("facebook", "done\n");
}
}
}
g_strfreev(splits);
}
void BuddyList::add_group_ok_cb(const char *name)
{
if (!name || !name[0]) {
LOG->Message(_("No group name specified."));
purple_blist_request_add_group();
return;
}
PurpleGroup *group = purple_group_new(name);
purple_blist_add_group(group, NULL);
}
static void
stress_login(PurpleAccount *account) {
PurpleConnection *pc = NULL;
PurpleGroup *g = NULL;
gint n_buddies = 0, i = 0, interval = 0, maxevents = 0;
/* build our possible events from the account settings */
add_event("trigger_signon", STRESS_EVENT_SIGN_ON, STRESS_EVENT_SIGN_OFF);
add_event("trigger_idle", STRESS_EVENT_IDLE, STRESS_EVENT_UNIDLE);
add_event("trigger_away", STRESS_EVENT_AWAY, STRESS_EVENT_BACK);
add_event("trigger_typing", STRESS_EVENT_TYPING, STRESS_EVENT_STOPPED_TYPING);
add_event("send_messages", STRESS_EVENT_SEND_MESSAGE, -1);
nevents = g_list_length(events);
/* get our connection and set it as online */
pc = purple_account_get_connection(account);
purple_connection_set_state(pc, PURPLE_CONNECTED);
/* grab the account settings we need for buddies */
n_buddies = purple_account_get_int(account, "nbuddies", 50);
maxevents = purple_account_get_int(account, "maxevents", 100);
interval = (guint)purple_account_get_int(account, "interval", 500);
message_min = purple_account_get_int(account, "message_min", 16);
message_max = purple_account_get_int(account, "message_max", 128);
g = purple_group_new("prpl-stress");
for(i = 0; i < n_buddies; i++) {
PurpleBuddy *b = NULL;
StressBuddy *sb = NULL;
gchar *name = NULL;
/* create the buddy and it's name */
name = g_strdup_printf("stress-%04x", i);
b = purple_buddy_new(account, name, NULL);
g_free(name);
/* add our data to the buddy */
sb = g_new0(StressBuddy, 1);
sb->buddy = b;
sb->maxevents = maxevents;
purple_buddy_set_protocol_data(b, sb);
/* add the buddy to our list and the purple blist */
buddies = g_list_prepend(buddies, sb);
purple_blist_add_buddy(b, NULL, g, NULL);
/* add our event timer to the buddy */
sb->timer_id = g_timeout_add(interval, stress_event_cb, sb);
}
}
void BuddyList::add_buddy_ok_cb(PurpleRequestFields *fields)
{
PurpleAccount *account = purple_request_fields_get_account(fields, "account");
const char *name = purple_request_fields_get_string(fields, "name");
const char *alias = purple_request_fields_get_string(fields, "alias");
int selected = purple_request_fields_get_choice(fields, "group");
GList *list = purple_request_field_choice_get_labels(
purple_request_fields_get_field(fields, "group"));
const char *group
= reinterpret_cast<const char*>(g_list_nth_data(list, selected));
bool err = false;
if (!account) {
LOG->Message(_("No account specified."));
err = true;
}
else if (!purple_account_is_connected(account)) {
LOG->Message(_("Selected account is not connected."));
err = true;
}
if (!name || !name[0]) {
LOG->Message(_("No buddy name specified."));
err = true;
}
if (!group || !group[0]) {
LOG->Message(_("No group name specified."));
err = true;
}
if (err) {
purple_blist_request_add_buddy(account, name, group, alias);
return;
}
PurpleGroup *g = purple_find_group(group);
if (!g) {
g = purple_group_new(group);
purple_blist_add_group(g, NULL);
}
PurpleBuddy *b = purple_find_buddy_in_group(account, name, g);
if (b) {
LOG->Message(_("Specified buddy is already in the list."));
return;
}
if (alias && !alias[0])
alias = NULL;
b = purple_buddy_new(account, name, alias);
purple_blist_add_buddy(b, NULL, g, NULL);
purple_account_add_buddy(account, b);
}
PurpleGroup *qq_group_find_or_new(const gchar *group_name)
{
PurpleGroup *g;
g_return_val_if_fail(group_name != NULL, NULL);
g = purple_find_group(group_name);
if (g == NULL) {
g = purple_group_new(group_name);
purple_blist_add_group(g, NULL);
purple_debug_warning("QQ", "Add new group: %s\n", group_name);
}
return g;
}
void rc_pop_contacts(PurpleGroup * grp)
{
if (!grp) return;
PurpleBlistNode * gnode = PURPLE_BLIST_NODE(grp);
PurpleBlistNode * n = NULL;
PurpleBuddy * b = NULL;
int total;
gboolean offline;
//XXX group->totalsize is unreliable!!!
for (n=gnode->child, total=0; n!=NULL; total++, n=n->next);
trace("Total Group Count %d", total);
while (total > g_size) {
n = gnode->child;
if (PURPLE_BLIST_NODE_IS_CONTACT(n)) {
trace("Child Contact : %s", (PURPLE_CONTACT(n)->priority->name));
b = PURPLE_CONTACT(n)->priority;
} else if (PURPLE_BLIST_NODE_IS_BUDDY(n)) {
trace("Child Buddy : %s", (PURPLE_BUDDY(n)->name));
b = PURPLE_BUDDY(n);
}
n = PURPLE_BLIST_NODE(b);
const char *name = purple_blist_node_get_string(n, NODE_GROUP_KEY);
if (!name) { // if cannot find orig group name, put back to Buddies
trace("ERROR!!! cannot find original group name");
name = "Buddies";
}
PurpleGroup * g = purple_find_group(name);
if (!g) {
trace("Group %s Not Found. Create one.", name);
g = purple_group_new(name);
}
trace("<<<<<<< Remove %s", b->name);
offline = purple_blist_node_get_bool(n, NODE_ORIG_OFFLINE_KEY);
purple_blist_node_set_bool(n, NODE_OFFLINE_KEY, offline);
purple_blist_add_buddy(b, NULL, g, NULL);
total--;
}
}
static void purple_add_buddy( struct im_connection *ic, char *who, char *group )
{
PurpleBuddy *pb;
PurpleGroup *pg = NULL;
if( group && !( pg = purple_find_group( group ) ) )
{
pg = purple_group_new( group );
purple_blist_add_group( pg, NULL );
}
pb = purple_buddy_new( (PurpleAccount*) ic->proto_data, who, NULL );
purple_blist_add_buddy( pb, NULL, pg, NULL );
purple_account_add_buddy( (PurpleAccount*) ic->proto_data, pb );
purple_gg_buddylist_export( ((PurpleAccount*)ic->proto_data)->gc );
}
static void
pb_got_phonebook(PushBulletAccount *pba, JsonNode *node, gpointer user_data)
{
PurpleAccount *account = pba->account;
JsonObject *rootobj = json_node_get_object(node);
JsonArray *phonebook = json_object_get_array_member(rootobj, "phonebook");
gint i;
guint len;
gchar *device = user_data;
PurpleGroup *pbgroup;
pbgroup = purple_find_group("PushBullet");
if (!pbgroup)
{
pbgroup = purple_group_new("PushBullet");
purple_blist_add_group(pbgroup, NULL);
}
for(i = 0, len = json_array_get_length(phonebook); i < len; i++)
{
JsonObject *number = json_array_get_object_element(phonebook, i);
const gchar *name = json_object_get_string_member(number, "name");
const gchar *phone = json_object_get_string_member(number, "phone");
const gchar *phone_type = json_object_get_string_member(number, "phone_type");
PurpleBuddy *pbuddy;
//Only handle the right 'type' of phone number.
//home, mobile, work, other
if (purple_account_get_bool(account, "mobile_contacts_only", FALSE) && phone_type[0] != 'm')
continue;
pbuddy = purple_find_buddy(account, phone);
if (!pbuddy)
{
pbuddy = purple_buddy_new(account, phone, name);
purple_blist_add_buddy(pbuddy, NULL, pbgroup, NULL);
purple_debug_info("pushbullet", "Added buddy %s %s\n", phone, name);
}
purple_prpl_got_user_status(account, phone, "mobile", NULL);
purple_prpl_got_user_status(account, phone, purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE), NULL);
}
g_free(device);
}
void Buddy::SetGroups (const QStringList& groups)
{
const auto& newGroup = groups.value (0);
PurpleGroup *group = 0;
if (!newGroup.isEmpty ())
{
const auto& utf8 = newGroup.toUtf8 ();
group = purple_find_group (utf8.constData ());
if (!group)
{
group = purple_group_new (utf8.constData ());
purple_blist_add_group (group, nullptr);
}
}
purple_blist_add_buddy (Buddy_, nullptr, group, nullptr);
}
static VALUE add_buddy(VALUE self, VALUE buddy)
{
PurpleAccount *account;
Data_Get_Struct(self, PurpleAccount, account);
PurpleBuddy* pb = purple_buddy_new(account, StringValueCStr(buddy), NULL);
char* group = _("Buddies");
PurpleGroup* grp = purple_find_group(group);
if (!grp)
{
grp = purple_group_new(group);
purple_blist_add_group(grp, NULL);
}
purple_blist_add_buddy(pb, NULL, grp, NULL);
purple_account_add_buddy(account, pb);
return Qtrue;
}
bool PurpleIMContactList::addGroupCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMContactList::_mutex);
PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn;
PurpleGroup *gGroup = purple_find_group( cbData->getGroupName().c_str() );
if (!gGroup)
{
gGroup = purple_group_new( cbData->getGroupName().c_str() );
purple_blist_add_group(gGroup, NULL);
}
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
void rc_push_contact(PurpleAccount *acct,
const char * buddyname)
{
PurpleGroup * grp = purple_find_group(GROUP_NAME);
if (!grp) {
trace("Group %s Not Found. Create one.", GROUP_NAME);
grp = purple_group_new(GROUP_NAME);
}
PurpleBuddy * buddy;
// if we can find it in 'Recent Contacts', skip
if ((buddy = purple_find_buddy_in_group(acct, buddyname, grp)) != NULL) {
trace("Buddy %s is already in %s", buddyname, GROUP_NAME);
purple_blist_add_buddy(buddy, NULL, grp, NULL);
return;
}
buddy = purple_find_buddy(acct, buddyname);
if (!buddy) {
trace("Buddy %s Not Found. You SUCK!", buddyname);
return;
}
PurpleBlistNode * node = PURPLE_BLIST_NODE(buddy);
// back up group info
PurpleGroup * orig_grp = purple_buddy_get_group(buddy);
purple_blist_node_set_string(node, NODE_GROUP_KEY, orig_grp->name);
// back up offline info
gboolean offline = purple_blist_node_get_bool(node, NODE_OFFLINE_KEY);
purple_blist_node_set_bool(node, NODE_ORIG_OFFLINE_KEY, offline);
purple_blist_node_set_bool(node, NODE_OFFLINE_KEY, TRUE);
// Add to Recent Contacts Group
trace(">>>>>>> Add %s", buddyname);
purple_blist_add_buddy(buddy, NULL, grp, NULL);
// Clean up old group if needed
rc_pop_contacts(grp);
}
Contact *QuetzalContactsFactory::addContact(const QString &id, const QVariantMap &data)
{
QByteArray group = data.value(QLatin1String("group")).toString().toUtf8();
if (group.isEmpty()) {
// For compatibility with other implementations
// Looks like libpurple doesn't support multiple groups
// Or does it at some unknown way
group = data.value(QLatin1String("tags")).toStringList().value(0).toUtf8();
}
QString name = data.value(QLatin1String("name")).toString();
const char *groupName = group.isEmpty() ? "Buddies" : group.constData();
PurpleGroup *pg = purple_find_group(groupName);
if (!pg) {
pg = purple_group_new(groupName);
purple_blist_add_group(pg, quetzal_blist_get_last_sibling(purple_blist_get_root()));
}
PurpleContact *pc = purple_contact_new();
purple_blist_add_contact(pc, pg, quetzal_blist_get_last_child(PURPLE_BLIST_NODE(pg)));
PurpleBuddy *buddy = purple_buddy_new(m_account->purple(), id.toUtf8().constData(),
name.toUtf8().constData());
PurpleBlistNode *node = PURPLE_BLIST_NODE(buddy);
purple_blist_add_buddy(buddy, pc, pg, quetzal_blist_get_last_child(PURPLE_BLIST_NODE(pc)));
QMapIterator<QString, QVariant> it(data.value(QLatin1String("quetzal_settings")).toMap());
while (it.hasNext()) {
it.next();
QByteArray key = it.key().toUtf8();
QVariant::Type type = it.value().type();
if (type == QVariant::Bool) {
purple_blist_node_set_bool(node, key.constData(), it.value().toBool());
} else if (type == QVariant::Int || type == QVariant::UInt
|| type == QVariant::LongLong || type == QVariant::ULongLong) {
purple_blist_node_set_int(node, key.constData(), it.value().toInt());
} else {
purple_blist_node_set_string(node, key.constData(), it.value().toString().toUtf8());
}
}
QuetzalContact *contact = reinterpret_cast<QuetzalContact*>(node->ui_data);
contact->update(buddy);
return contact;
}
void on_ready (struct tgl_state *TLS) {
debug ("on_ready().\n");
telegram_conn *conn = TLS->ev_base;
purple_connection_set_state(conn->gc, PURPLE_CONNECTED);
purple_connection_set_display_name(conn->gc, purple_account_get_username(conn->pa));
purple_blist_add_account(conn->pa);
tggroup = purple_find_group("Telegram");
if (tggroup == NULL) {
debug ("PurpleGroup = NULL, creating");
tggroup = purple_group_new ("Telegram");
purple_blist_add_group (tggroup, NULL);
}
debug ("seq = %d, pts = %d\n", TLS->seq, TLS->pts);
tgl_do_get_difference (TLS, 0, 0, 0);
tgl_do_get_dialog_list (TLS, 0, 0);
tgl_do_update_contact_list (TLS, 0, 0);
conn->timer = purple_timeout_add (5000, queries_timerfunc, conn);
}
static void
lsg_cmd (MsnCmdProc *cmdproc,
MsnCommand *cmd)
{
MsnSession *session = cmdproc->session;
char *name;
const gchar *group_guid;
name = pn_url_decode (cmd->params[0]);
group_guid = cmd->params[1];
if (strcmp(name, MSN_NULL_GROUP_NAME) == 0) {
pn_error("Invalid group name, ignoring");
goto leave;
}
pn_group_new (session->contactlist, name, group_guid);
if (!purple_find_group (name))
{
PurpleGroup *g = purple_group_new (name);
purple_blist_add_group (g, NULL);
}
/* Group of ungroupped buddies */
if (!group_guid)
{
if (session->sync->total_users == 0)
{
cmdproc->cbs_table = session->sync->old_cbs_table;
msn_session_finish_login (session);
msn_sync_destroy (session->sync);
session->sync = NULL;
}
}
leave:
g_free (name);
}
/*add group id to User object*/
void
msn_user_add_group_id(MsnUser *user, const char* group_id)
{
MsnUserList *userlist;
PurpleAccount *account;
PurpleBuddy *b;
PurpleGroup *g;
const char *passport;
const char *group_name;
g_return_if_fail(user != NULL);
g_return_if_fail(group_id != NULL);
user->group_ids = g_list_append(user->group_ids, g_strdup(group_id));
userlist = user->userlist;
account = userlist->session->account;
passport = msn_user_get_passport(user);
group_name = msn_userlist_find_group_name(userlist, group_id);
purple_debug_info("msn", "User: group id:%s,name:%s,user:%s\n", group_id, group_name, passport);
g = purple_find_group(group_name);
if ((group_id == NULL) && (g == NULL))
{
g = purple_group_new(group_name);
purple_blist_add_group(g, NULL);
}
b = purple_find_buddy_in_group(account, passport, g);
if (b == NULL)
{
b = purple_buddy_new(account, passport, NULL);
purple_blist_add_buddy(b, NULL, g, NULL);
}
purple_buddy_set_protocol_data(b, user);
/*Update the blist Node info*/
}
static VALUE remove_buddy(VALUE self, VALUE buddy)
{
PurpleAccount *account;
Data_Get_Struct(self, PurpleAccount, account);
PurpleBuddy* pb = purple_find_buddy(account, StringValueCStr(buddy));
if (NULL == pb) {
rb_raise(rb_eRuntimeError, "Failed to remove buddy for %s : %s does not exist", purple_account_get_username(account), StringValueCStr(buddy));
}
char* group = _("Buddies");
PurpleGroup* grp = purple_find_group(group);
if (!grp)
{
grp = purple_group_new(group);
purple_blist_add_group(grp, NULL);
}
purple_blist_remove_buddy(pb);
purple_account_remove_buddy(account, pb, grp);
return Qtrue;
}
static void
lsg_cmd (MsnCmdProc *cmdproc,
MsnCommand *cmd)
{
MsnSession *session = cmdproc->session;
char *name;
const gchar *group_guid;
name = pn_url_decode (cmd->params[0]);
group_guid = cmd->params[1];
pn_group_new (session->contactlist, name, group_guid);
if (!purple_find_group (name))
{
PurpleGroup *g = purple_group_new (name);
purple_blist_add_group (g, NULL);
}
g_free (name);
/* Group of ungroupped buddies */
if (!group_guid)
{
if (session->sync->total_users == 0)
{
cmdproc->cbs_table = session->sync->old_cbs_table;
msn_session_finish_login (session);
msn_sync_destroy (session->sync);
session->sync = NULL;
}
return;
}
}
static VALUE add_buddy(VALUE self, VALUE buddy)
{
PurpleAccount *account = NULL;
PurpleConnection *gc = NULL;
Data_Get_Struct(self, PurpleAccount, account);
gc = purple_account_get_connection( account );
PurpleBuddy* pb = purple_buddy_new(account, RSTRING_PTR(buddy), NULL);
char* group = _("Buddies");
PurpleGroup* grp = purple_find_group(group);
if (!grp)
{
grp = purple_group_new(group);
purple_blist_add_group(grp, NULL);
}
purple_blist_add_buddy(pb, NULL, grp, NULL);
purple_account_add_buddy(account, pb);
serv_add_permit( gc, RSTRING_PTR(buddy) );
return Qtrue;
}
static PurpleBuddy *add_buddy(FacebookAccount *fba,
const gchar *friend_list_id, const gchar *uid, GHashTable *cur_groups)
{
const gchar *group_name;
PurpleGroup *fb_group;
PurpleBuddy *buddy;
group_name = g_hash_table_lookup(fba->friend_lists, purple_normalize_nocase(NULL, friend_list_id));
if (!group_name || group_name[0] == '\0') {
purple_debug_info("facebook",
"did not find name of list %s\n",
friend_list_id);
group_name = DEFAULT_GROUP_NAME;
}
// Initialize group as necessary.
fb_group = purple_find_group(group_name);
if (fb_group == NULL)
{
purple_debug_info("facebook", "adding friend list %s\n",
group_name);
fb_group = purple_group_new(group_name);
purple_blist_add_group(fb_group, NULL);
}
buddy = (PurpleBuddy *)g_hash_table_lookup(cur_groups, purple_normalize_nocase(NULL, group_name));
if (!buddy) {
purple_debug_info("facebook", "adding %s to %s\n",
uid, group_name);
buddy = purple_buddy_new(fba->account, uid, NULL);
purple_blist_add_buddy(buddy, NULL, fb_group, NULL);
g_hash_table_remove(cur_groups, purple_normalize_nocase(NULL, group_name));
}
return buddy;
}
GList *fb_get_buddies_friend_list (FacebookAccount *fba,
const gchar *uid, JsonArray *friend_list_ids)
{
GSList *buddies;
GSList *cur;
GHashTable *cur_groups;
int i;
GList *final_buddies, *cur_buddy;
PurpleGroup *fb_group;
PurpleBuddy *buddy;
final_buddies = NULL;
buddies = purple_find_buddies(fba->account, uid);
// If we're already in the buddy list, stop. Ignore FB info because
// it will be incorrect.
if (atoll(uid) == fba->uid && buddies != NULL) {
purple_debug_info("facebook",
"already have buddies for self, not adding\n");
for (cur = buddies; cur != NULL; cur = cur->next)
{
final_buddies = g_list_append(
final_buddies, cur->data);
}
g_slist_free(buddies);
return final_buddies;
}
//Do we want to ignore groups?
if (!purple_account_get_bool(fba->account, "facebook_use_groups", TRUE))
{
if (buddies != NULL) {
//Copy the slist into the list
for (cur = buddies; cur != NULL; cur = cur->next)
{
final_buddies = g_list_append(
final_buddies, cur->data);
}
g_slist_free(buddies);
return final_buddies;
} else {
buddy = purple_buddy_new(fba->account, uid, NULL);
fb_group = purple_find_group(DEFAULT_GROUP_NAME);
if (fb_group == NULL)
{
fb_group = purple_group_new(DEFAULT_GROUP_NAME);
purple_blist_add_group(fb_group, NULL);
}
purple_blist_add_buddy(buddy, NULL, fb_group, NULL);
final_buddies = g_list_append(final_buddies, buddy);
return final_buddies;
}
}
// Determine what buddies exist and what groups they are in.
cur_groups = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, NULL);
for (cur = buddies; cur != NULL; cur = cur->next)
{
const gchar *group_name;
group_name = purple_group_get_name(purple_buddy_get_group(
(PurpleBuddy *)cur->data));
group_name = purple_normalize_nocase(NULL, group_name);
g_hash_table_insert(cur_groups, g_strdup(group_name), cur->data);
}
g_slist_free(buddies);
// Create/insert necessary buddies
if (friend_list_ids) {
for (i = 0; i < json_array_get_length(friend_list_ids); i++)
{
const gchar *friend_list_id;
friend_list_id = json_node_get_string(
json_array_get_element(friend_list_ids, i));
buddy = add_buddy(fba, friend_list_id, uid, cur_groups);
final_buddies = g_list_append(final_buddies, buddy);
}
} else {
// No friend list data, so we use the default group.
final_buddies = g_list_append(final_buddies,
add_buddy(fba, "-1", uid, cur_groups));
}
// Figure out which groups/buddies are not represented.
for (cur_buddy = final_buddies; cur_buddy != NULL;
cur_buddy = cur_buddy->next)
{
const gchar *group_name = purple_group_get_name(purple_buddy_get_group(
(PurpleBuddy *)cur_buddy->data));
g_hash_table_remove(cur_groups, purple_normalize_nocase(NULL, group_name));
}
// Delete remaining buddies to maintain sync state with server.
g_hash_table_foreach(cur_groups, destroy_buddy, fba);
// Cleanup!
g_hash_table_destroy(cur_groups);
return final_buddies;
}
