src/purple/purple-buddy.c

   1 /**
   2  * @file purple-buddy.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-2018 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <glib.h>
  28
  29 #include "notify.h"
  30 #include "request.h"
  31
  32 #include "version.h"
  33 #if PURPLE_VERSION_CHECK(3,0,0)
  34 #include "account.h"
  35 #include "buddylist.h"
  36 #else
  37 #include "blist.h"
  38 #include "privacy.h"
  39 #define purple_account_privacy_check(a, n)             purple_privacy_check(a, n)
  40 #define purple_account_privacy_deny_add(a, n, l)       purple_privacy_deny_add(a, n, l)
  41 #define purple_account_privacy_deny_remove(a, n, l)    purple_privacy_deny_remove(a, n, l)
  42 #define purple_blist_find_buddies(a, n)                purple_find_buddies(a, n)
  43 #define purple_blist_find_buddy(a, n)                  purple_find_buddy(a, n)
  44 #define purple_blist_find_buddy_in_group(a, n, g)      purple_find_buddy_in_group(a, n, g)
  45 #define purple_blist_find_group(n)                     purple_find_group(n)
  46 #define purple_buddy_set_local_alias(b, n)             purple_blist_alias_buddy(b, n)
  47 #define purple_buddy_set_server_alias(b, n)            purple_blist_server_alias_buddy(b, n)
  48 #define purple_buddy_set_name(b, n)                    purple_blist_rename_buddy(b, n)
  49 #define purple_group_set_name(g, n)                    purple_blist_rename_group(g, n)
  50 #define purple_notify_user_info_add_pair_html(i, k, v) purple_notify_user_info_add_pair(i, k, v)
  51 #define purple_protocol_got_user_status                purple_prpl_got_user_status
  52 #define PURPLE_IS_BUDDY(b)                             PURPLE_BLIST_NODE_IS_BUDDY(b)
  53 #define PURPLE_IS_GROUP(b)                             PURPLE_BLIST_NODE_IS_GROUP(b)
  54 #endif
  55
  56 #include "sipe-common.h"
  57 #include "sipe-backend.h"
  58 #include "sipe-core.h"
  59 #include "sipe-nls.h"
  60
  61 #include "purple-private.h"
  62
  63 static const struct {
  64         const gchar *property;    /* property name to store in blist.xml */
  65         const gchar *description; /* label for "Get Info" dialog */
  66 } buddy_info_map[] = {
  67 /* SIPE_BUDDY_INFO_DISPLAY_NAME          */ { "alias",                 N_("Display name")   },
  68 /* SIPE_BUDDY_INFO_JOB_TITLE             */ { "title",                 N_("Job title")      },
  69 /* SIPE_BUDDY_INFO_CITY                  */ { "address-city",          N_("City")           },
  70 /* SIPE_BUDDY_INFO_STATE                 */ { "address-state",         N_("State")          },
  71 /* SIPE_BUDDY_INFO_OFFICE                */ { "office",                N_("Office")         },
  72 /* SIPE_BUDDY_INFO_DEPARTMENT            */ { "department",            NULL                 },
  73 /* SIPE_BUDDY_INFO_COUNTRY               */ { "address-country-code",  N_("Country")        },
  74 /* SIPE_BUDDY_INFO_WORK_PHONE            */ { "phone",                 N_("Business phone") },
  75 /* SIPE_BUDDY_INFO_WORK_PHONE_DISPLAY    */ { "phone-display",         NULL                 },
  76 /* SIPE_BUDDY_INFO_COMPANY               */ { "company",               N_("Company")        },
  77 /* SIPE_BUDDY_INFO_EMAIL                 */ { "email",                 N_("Email address")  },
  78 /* SIPE_BUDDY_INFO_SITE                  */ { "site",                  N_("Site")           },
  79 /* SIPE_BUDDY_INFO_ZIPCODE               */ { "address-zipcode",       NULL                 },
  80 /* SIPE_BUDDY_INFO_STREET                */ { "address-street",        NULL                 },
  81 /* SIPE_BUDDY_INFO_MOBILE_PHONE          */ { "phone-mobile",          NULL                 },
  82 /* SIPE_BUDDY_INFO_MOBILE_PHONE_DISPLAY  */ { "phone-mobile-display",  NULL                 },
  83 /* SIPE_BUDDY_INFO_HOME_PHONE            */ { "phone-home",            NULL                 },
  84 /* SIPE_BUDDY_INFO_HOME_PHONE_DISPLAY    */ { "phone-home-display",    NULL                 },
  85 /* SIPE_BUDDY_INFO_OTHER_PHONE           */ { "phone-other",           NULL                 },
  86 /* SIPE_BUDDY_INFO_OTHER_PHONE_DISPLAY   */ { "phone-other-display",   NULL                 },
  87 /* SIPE_BUDDY_INFO_CUSTOM1_PHONE         */ { "phone-custom1",         NULL                 },
  88 /* SIPE_BUDDY_INFO_CUSTOM1_PHONE_DISPLAY */ { "phone-custom1-display", NULL                 },
  89 /* SIPE_BUDDY_INFO_ALIAS                 */ { NULL,                    N_("Alias")          },
  90 /* SIPE_BUDDY_INFO_DEVICE                */ { NULL,                    N_("Device")         },
  91 };
  92
  93 #define buddy_info_property(i)    buddy_info_map[i].property
  94 #define buddy_info_description(i) gettext(buddy_info_map[i].description)
  95
  96 sipe_backend_buddy sipe_backend_buddy_find(struct sipe_core_public *sipe_public,
  97                                            const gchar *buddy_name,
  98                                            const gchar *group_name)
  99 {
 100         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 101         PurpleGroup *purple_group;
 102
 103         if (group_name)
 104         {
 105                 purple_group = purple_blist_find_group(group_name);
 106                 if (!purple_group)
 107                         return NULL;
 108
 109                 return purple_blist_find_buddy_in_group(purple_private->account,
 110                                                         buddy_name,
 111                                                         purple_group);
 112         } else {
 113                 return purple_blist_find_buddy(purple_private->account,
 114                                                buddy_name);
 115         }
 116 }
 117
 118 GSList* sipe_backend_buddy_find_all(struct sipe_core_public *sipe_public,
 119                                     const gchar *buddy_name,
 120                                     const gchar *group_name)
 121 {
 122         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 123
 124         if (group_name)
 125         {
 126                 SIPE_DEBUG_ERROR_NOFORMAT("Finding all buddies in a group not supported on purple");
 127                 return NULL;
 128         }
 129
 130         return purple_blist_find_buddies(purple_private->account, buddy_name);
 131 }
 132
 133 gchar* sipe_backend_buddy_get_name(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 134                                    const sipe_backend_buddy who)
 135 {
 136         return g_strdup(purple_buddy_get_name((PurpleBuddy *) who));
 137 }
 138
 139 gchar* sipe_backend_buddy_get_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 140                                     const sipe_backend_buddy who)
 141 {
 142         return g_strdup(purple_buddy_get_alias(who));
 143 }
 144
 145 gchar* sipe_backend_buddy_get_server_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 146                                            const sipe_backend_buddy who)
 147 {
 148         return g_strdup(purple_buddy_get_server_alias(who));
 149 }
 150
 151 gchar *sipe_backend_buddy_get_local_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 152                                           const sipe_backend_buddy who)
 153 {
 154         return g_strdup(
 155 #if PURPLE_VERSION_CHECK(3,0,0)
 156                 purple_buddy_get_local_alias(who)
 157 #else
 158                 purple_buddy_get_local_buddy_alias(who)
 159 #endif
 160                 );
 161 }
 162
 163 gchar* sipe_backend_buddy_get_group_name(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 164                                          const sipe_backend_buddy who)
 165 {
 166         return g_strdup(purple_group_get_name(purple_buddy_get_group((PurpleBuddy*)who)));
 167 }
 168
 169 guint sipe_backend_buddy_get_status(struct sipe_core_public *sipe_public,
 170                                     const gchar *uri)
 171 {
 172         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 173         PurpleBuddy *pbuddy = purple_blist_find_buddy(purple_private->account, uri);
 174         const PurplePresence *presence = purple_buddy_get_presence(pbuddy);
 175         const PurpleStatus *pstatus = purple_presence_get_active_status(presence);
 176         return(sipe_purple_token_to_activity(purple_status_get_id(pstatus)));
 177 }
 178
 179 void sipe_backend_buddy_set_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 180                                   const sipe_backend_buddy who,
 181                                   const gchar *alias)
 182 {
 183         purple_buddy_set_local_alias(who, alias);
 184 }
 185
 186 void sipe_backend_buddy_set_server_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 187                                          const sipe_backend_buddy who,
 188                                          const gchar *alias)
 189 {
 190         purple_buddy_set_server_alias(who, alias);
 191 }
 192
 193 gchar* sipe_backend_buddy_get_string(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 194                                      sipe_backend_buddy buddy,
 195                                      const sipe_buddy_info_fields key)
 196 {
 197         PurpleBuddy *b = (PurpleBuddy*) buddy;
 198         return g_strdup(purple_blist_node_get_string(&b->node, buddy_info_property(key)));
 199 }
 200
 201 void sipe_backend_buddy_set_string(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 202                                    sipe_backend_buddy buddy,
 203                                    const sipe_buddy_info_fields key,
 204                                    const gchar *val)
 205 {
 206         PurpleBuddy *b = (PurpleBuddy*) buddy;
 207         purple_blist_node_set_string(&b->node, buddy_info_property(key), val);
 208 }
 209
 210 void sipe_backend_buddy_refresh_properties(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 211                                            SIPE_UNUSED_PARAMETER const gchar *uri)
 212 {
 213         /* nothing to do here: already taken care of by libpurple */
 214 }
 215
 216 void sipe_backend_buddy_list_processing_start(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public)
 217 {
 218 }
 219
 220 void sipe_backend_buddy_list_processing_finish(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public)
 221 {
 222 }
 223
 224 sipe_backend_buddy sipe_backend_buddy_add(struct sipe_core_public *sipe_public,
 225                                           const gchar *name,
 226                                           const gchar *alias,
 227                                           const gchar *groupname)
 228 {
 229         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 230         PurpleBuddy *b;
 231         PurpleGroup *purple_group = purple_blist_find_group(groupname);
 232
 233         if (!purple_group)
 234                 return NULL;
 235
 236         b = purple_buddy_new(purple_private->account, name, alias);
 237         purple_blist_add_buddy(b, NULL, purple_group, NULL);
 238         return b;
 239 }
 240
 241 void sipe_backend_buddy_remove(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 242                                const sipe_backend_buddy who)
 243 {
 244         purple_blist_remove_buddy(who);
 245 }
 246
 247 void sipe_backend_buddy_request_authorization(struct sipe_core_public *sipe_public,
 248                                               const gchar *who,
 249                                               const gchar *alias,
 250                                               gboolean on_list,
 251                                               sipe_backend_buddy_request_authorization_cb auth_cb,
 252                                               sipe_backend_buddy_request_authorization_cb deny_cb,
 253                                               gpointer data)
 254 {
 255         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 256
 257         purple_account_request_authorization(
 258                 purple_private->account,
 259                 who,
 260                 _("you"), /* id */
 261                 alias,
 262                 NULL, /* message */
 263                 on_list,
 264                 (PurpleAccountRequestAuthorizationCb) auth_cb,
 265                 (PurpleAccountRequestAuthorizationCb) deny_cb,
 266                 data);
 267
 268 }
 269
 270 void sipe_backend_buddy_request_add(struct sipe_core_public *sipe_public,
 271                                     const gchar *who,
 272                                     const gchar *alias)
 273 {
 274         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 275
 276         purple_account_request_add(purple_private->account,
 277                                    who,
 278                                    _("you"),
 279                                    alias,
 280                                    NULL);
 281
 282 }
 283
 284 gboolean sipe_backend_buddy_is_blocked(struct sipe_core_public *sipe_public,
 285                                        const gchar *who)
 286 {
 287         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 288
 289         return(!purple_account_privacy_check(purple_private->account, who));
 290 }
 291
 292 void sipe_backend_buddy_set_blocked_status(struct sipe_core_public *sipe_public,
 293                                       const gchar *who,
 294                                       gboolean blocked)
 295 {
 296         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 297
 298         if (blocked) {
 299                 purple_account_privacy_deny_add(purple_private->account, who, TRUE);
 300         } else {
 301                 purple_account_privacy_deny_remove(purple_private->account, who, TRUE);
 302         }
 303
 304         /* stupid workaround to make pidgin re-render screen to reflect our changes */
 305         SIPE_DEBUG_INFO_NOFORMAT("sipe_backend_buddy_set_blocked_status: forcefully refreshing screen.");
 306         sipe_core_buddy_got_status(sipe_public,
 307                                    who,
 308                                    sipe_backend_buddy_get_status(sipe_public,
 309                                                                  who));
 310 }
 311
 312 void sipe_backend_buddy_set_status(struct sipe_core_public *sipe_public,
 313                                    const gchar *who,
 314                                    guint activity)
 315 {
 316         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 317         PurpleBuddy *buddy = NULL;
 318         gchar *tmp = NULL;
 319
 320         buddy = purple_blist_find_buddy(purple_private->account, who);
 321
 322         if (buddy) {
 323                 const PurpleStatusType *status_type =
 324                         purple_status_type_find_with_id(
 325                                 purple_account_get_status_types(purple_private->account),
 326                                 sipe_purple_activity_to_token(activity));
 327                 tmp = sipe_core_buddy_status(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 328                                              purple_buddy_get_name(buddy),
 329                                              activity,
 330                                              purple_status_type_get_name(status_type));
 331         }
 332
 333         /* make sure to clear status message when there is none */
 334         if (!tmp)
 335                 tmp = g_strdup("");
 336
 337         purple_protocol_got_user_status(purple_private->account, who,
 338                                         sipe_purple_activity_to_token(activity),
 339                                         SIPE_PURPLE_STATUS_ATTR_ID_MESSAGE, tmp,
 340                                         NULL);
 341         g_free(tmp);
 342 }
 343
 344 gboolean sipe_backend_uses_photo(void)
 345 {
 346         return TRUE;
 347 }
 348
 349 void sipe_backend_buddy_set_photo(struct sipe_core_public *sipe_public,
 350                                   const gchar *who,
 351                                   gpointer photo_data,
 352                                   gsize data_len,
 353                                   const gchar *photo_hash)
 354 {
 355         PurpleAccount *account = sipe_public->backend_private->account;
 356
 357         purple_buddy_icons_set_for_user(account, who, photo_data,
 358                                         data_len, photo_hash);
 359 }
 360
 361 const gchar *sipe_backend_buddy_get_photo_hash(struct sipe_core_public *sipe_public,
 362                                                const gchar *who)
 363 {
 364         PurpleAccount *account = sipe_public->backend_private->account;
 365         const gchar *result = NULL;
 366
 367         PurpleBuddyIcon *icon = purple_buddy_icons_find(account, who);
 368         if (icon) {
 369                 result = purple_buddy_icon_get_checksum(icon);
 370                 purple_buddy_icon_unref(icon);
 371         }
 372
 373         return result;
 374 }
 375
 376 gboolean sipe_backend_buddy_group_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 377                                       const gchar *group_name)
 378 {
 379         PurpleGroup * purple_group = purple_blist_find_group(group_name);
 380         if (!purple_group) {
 381                 purple_group = purple_group_new(group_name);
 382                 purple_blist_add_group(purple_group, NULL);
 383         }
 384
 385         return (purple_group != NULL);
 386 }
 387
 388 gboolean sipe_backend_buddy_group_rename(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 389                                          const gchar *old_name,
 390                                          const gchar *new_name)
 391 {
 392         PurpleGroup *purple_group = purple_blist_find_group(old_name);
 393         if (purple_group)
 394                 purple_group_set_name(purple_group, new_name);
 395         return(purple_group != NULL);
 396 }
 397
 398 void sipe_backend_buddy_group_remove(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 399                                      const gchar *group_name)
 400 {
 401         PurpleGroup *purple_group = purple_blist_find_group(group_name);
 402         if (purple_group)
 403                 purple_blist_remove_group(purple_group);
 404 }
 405
 406 struct sipe_backend_buddy_info *sipe_backend_buddy_info_start(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public)
 407 {
 408         return((struct sipe_backend_buddy_info *)purple_notify_user_info_new());
 409 }
 410
 411 void sipe_backend_buddy_info_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 412                                  struct sipe_backend_buddy_info *info,
 413                                  sipe_buddy_info_fields key,
 414                                  const gchar *value)
 415 {
 416         if (info) {
 417                 purple_notify_user_info_add_pair_html((PurpleNotifyUserInfo *) info,
 418                                                       buddy_info_description(key),
 419                                                       value);
 420         }
 421 }
 422
 423 void sipe_backend_buddy_info_break(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 424                                    struct sipe_backend_buddy_info *info)
 425 {
 426         purple_notify_user_info_add_section_break((PurpleNotifyUserInfo *) info);
 427 }
 428
 429 void sipe_backend_buddy_info_finalize(struct sipe_core_public *sipe_public,
 430                                       struct sipe_backend_buddy_info *info,
 431                                       const gchar *uri)
 432 {
 433         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 434
 435         /* show a buddy's user info in a nice dialog box */
 436         purple_notify_userinfo(purple_private->gc,
 437                                uri,       /* buddy's URI */
 438                                (PurpleNotifyUserInfo *) info,
 439                                NULL,      /* callback called when dialog closed */
 440                                NULL);     /* userdata for callback */
 441 }
 442
 443 void sipe_backend_buddy_tooltip_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 444                                     struct sipe_backend_buddy_tooltip *tooltip,
 445                                     const gchar *description,
 446                                     const gchar *value)
 447 {
 448         purple_notify_user_info_add_pair_html((PurpleNotifyUserInfo *) tooltip,
 449                                               description,
 450                                               value);
 451 }
 452
 453 void sipe_purple_add_buddy(PurpleConnection *gc,
 454                            PurpleBuddy *buddy,
 455                            PurpleGroup *group
 456 #if PURPLE_VERSION_CHECK(3,0,0)
 457                            , SIPE_UNUSED_PARAMETER const gchar *message
 458 #endif
 459         )
 460 {
 461         SIPE_DEBUG_INFO("sipe_purple_add_buddy[CB]: buddy:%s group:%s",
 462                         buddy ? purple_buddy_get_name(buddy) : "",
 463                         group ? purple_group_get_name(group) : "");
 464
 465         /* libpurple can call us with undefined buddy or group */
 466         if (buddy && group) {
 467                 /*
 468                  * Buddy name must be lower case as we use
 469                  * purple_normalize_nocase() to compare
 470                  */
 471                 gchar *buddy_name = g_ascii_strdown(purple_buddy_get_name(buddy), -1);
 472                 gchar *uri        = sip_uri_if_valid(buddy_name);
 473                 g_free(buddy_name);
 474
 475                 if (uri) {
 476                         purple_buddy_set_name(buddy, uri);
 477                         g_free(uri);
 478
 479                         sipe_core_buddy_add(PURPLE_GC_TO_SIPE_CORE_PUBLIC,
 480                                             purple_buddy_get_name(buddy),
 481                                             purple_group_get_name(group));
 482                 } else {
 483                         SIPE_DEBUG_ERROR_NOFORMAT("sipe_purple_add_buddy[CB]: buddy name is invalid for URI");
 484                         purple_blist_remove_buddy(buddy);
 485                         purple_notify_error(gc, NULL,
 486                                             _("User name should be a valid SIP URI\nExample: user@company.com"),
 487                                             NULL
 488 #if PURPLE_VERSION_CHECK(3,0,0)
 489                                             , NULL
 490 #endif
 491                                             );
 492                 }
 493         }
 494 }
 495
 496 void sipe_purple_remove_buddy(PurpleConnection *gc,
 497                               PurpleBuddy *buddy,
 498                               PurpleGroup *group)
 499 {
 500         SIPE_DEBUG_INFO("sipe_purple_remove_buddy[CB]: buddy: '%s' group: '%s'",
 501                         buddy ? purple_buddy_get_name(buddy) : "",
 502                         group ? purple_group_get_name(group) : "");
 503         if (!buddy) return;
 504
 505         sipe_core_buddy_remove(PURPLE_GC_TO_SIPE_CORE_PUBLIC,
 506                                purple_buddy_get_name(buddy),
 507                                group ? purple_group_get_name(group) : NULL);
 508 }
 509
 510 void sipe_purple_group_buddy(PurpleConnection *gc,
 511                              const char *who,
 512                              const char *old_group_name,
 513                              const char *new_group_name)
 514 {
 515         sipe_core_buddy_group(PURPLE_GC_TO_SIPE_CORE_PUBLIC, who, old_group_name, new_group_name);
 516 }
 517
 518 /* Buddy Menu Handling */
 519
 520 static void sipe_purple_buddy_make_chat_leader_cb(PurpleBuddy *buddy,
 521                                                   gpointer parameter)
 522 {
 523         SIPE_DEBUG_INFO("sipe_purple_buddy_make_chat_leader_cb: name '%s'",
 524                         purple_buddy_get_name(buddy));
 525         sipe_core_conf_make_leader(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 526                                    parameter,
 527                                    purple_buddy_get_name(buddy));
 528 }
 529
 530 static void sipe_purple_buddy_remove_from_chat_cb(PurpleBuddy *buddy,
 531                                                   gpointer parameter)
 532 {
 533         SIPE_DEBUG_INFO("sipe_purple_buddy_remove_from_chat_cb: name '%s'",
 534                         purple_buddy_get_name(buddy));
 535         sipe_core_conf_remove_from(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 536                                    parameter,
 537                                    purple_buddy_get_name(buddy));
 538 }
 539
 540 static void sipe_purple_buddy_invite_to_chat_cb(PurpleBuddy *buddy,
 541                                                 gpointer parameter)
 542 {
 543         SIPE_DEBUG_INFO("sipe_purple_buddy_invite_to_chat_cb: name '%s'",
 544                         purple_buddy_get_name(buddy));
 545         sipe_core_chat_invite(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 546                               parameter,
 547                               purple_buddy_get_name(buddy));
 548 }
 549
 550 static void sipe_purple_buddy_new_chat_cb(PurpleBuddy *buddy,
 551                                           SIPE_UNUSED_PARAMETER gpointer parameter)
 552 {
 553         SIPE_DEBUG_INFO("sipe_purple_buddy_new_chat_cb: name '%s'",
 554                         purple_buddy_get_name(buddy));
 555         sipe_core_buddy_new_chat(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 556                                  purple_buddy_get_name(buddy));
 557 }
 558
 559 static void sipe_purple_buddy_make_call_cb(PurpleBuddy *buddy,
 560                                            gpointer parameter)
 561 {
 562         SIPE_DEBUG_INFO("sipe_purple_buddy_make_call_cb: name '%s'",
 563                         purple_buddy_get_name(buddy));
 564         sipe_core_buddy_make_call(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 565                                   parameter);
 566 }
 567
 568 static void sipe_purple_buddy_send_email_cb(PurpleBuddy *buddy,
 569                                             SIPE_UNUSED_PARAMETER gpointer parameter)
 570 {
 571         SIPE_DEBUG_INFO("sipe_purple_buddy_send_email_cb: name '%s'",
 572                         purple_buddy_get_name(buddy));
 573         sipe_core_buddy_send_email(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 574                                    purple_buddy_get_name(buddy));
 575 }
 576
 577 static void sipe_purple_buddy_access_level_help_cb(PurpleBuddy *buddy,
 578                                                    SIPE_UNUSED_PARAMETER gpointer parameter)
 579 {
 580         /**
 581          * Translators: replace with URL to localized page
 582          * If it doesn't exist copy the original URL
 583          */
 584         purple_notify_uri(purple_account_get_connection(purple_buddy_get_account(buddy)),
 585                           _("https://sourceforge.net/apps/mediawiki/sipe/index.php?title=Access_Levels"));
 586 }
 587
 588 static void sipe_purple_buddy_change_access_level_cb(PurpleBuddy *buddy,
 589                                                      gpointer parameter)
 590 {
 591         sipe_core_change_access_level_from_container(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 592                                                      parameter);
 593 }
 594
 595 static void sipe_purple_ask_access_domain_cb(PurpleConnection *gc,
 596                                              PurpleRequestFields *fields)
 597 {
 598         const gchar *domain = purple_request_fields_get_string(fields, "access_domain");
 599         guint index         =
 600 #if PURPLE_VERSION_CHECK(3,0,0)
 601                 GPOINTER_TO_UINT(
 602 #endif
 603                         purple_request_fields_get_choice(fields, "container_id")
 604 #if PURPLE_VERSION_CHECK(3,0,0)
 605                                 )
 606 #endif
 607                 ;
 608
 609         sipe_core_change_access_level_for_domain(PURPLE_GC_TO_SIPE_CORE_PUBLIC,
 610                                                  domain,
 611                                                  index);
 612 }
 613
 614 static void sipe_purple_buddy_add_new_domain_cb(PurpleBuddy *buddy,
 615                                                 SIPE_UNUSED_PARAMETER gpointer parameter)
 616 {
 617         PurpleAccount *account = purple_buddy_get_account(buddy);
 618         PurpleConnection *gc = purple_account_get_connection(account);
 619         PurpleRequestFields *fields;
 620         PurpleRequestFieldGroup *g;
 621         PurpleRequestField *f;
 622
 623         fields = purple_request_fields_new();
 624
 625         g = purple_request_field_group_new(NULL);
 626         f = purple_request_field_string_new("access_domain",
 627                                             _("Domain"),
 628                                             "partner-company.com",
 629                                             FALSE);
 630         purple_request_field_set_required(f, TRUE);
 631         purple_request_field_group_add_field(g, f);
 632
 633         f = purple_request_field_choice_new("container_id",
 634                                             _("Access level"),
 635                                             0);
 636 #if PURPLE_VERSION_CHECK(3,0,0)
 637         purple_request_field_choice_add(f, _("Personal"), GUINT_TO_POINTER(0));
 638         purple_request_field_choice_add(f, _("Team"),     GUINT_TO_POINTER(1));
 639         purple_request_field_choice_add(f, _("Company"),  GUINT_TO_POINTER(2));
 640         purple_request_field_choice_add(f, _("Public"),   GUINT_TO_POINTER(3));
 641         purple_request_field_choice_add(f, _("Blocked"),  GUINT_TO_POINTER(4));
 642         purple_request_field_choice_set_default_value(f,  GUINT_TO_POINTER(3));
 643 #else
 644         purple_request_field_choice_add(f, _("Personal")); /* index 0 */
 645         purple_request_field_choice_add(f, _("Team"));
 646         purple_request_field_choice_add(f, _("Company"));
 647         purple_request_field_choice_add(f, _("Public"));
 648         purple_request_field_choice_add(f, _("Blocked")); /* index 4 */
 649         purple_request_field_choice_set_default_value(f, 3); /* index */
 650 #endif
 651         purple_request_field_set_required(f, TRUE);
 652         purple_request_field_group_add_field(g, f);
 653
 654         purple_request_fields_add_group(fields, g);
 655
 656         purple_request_fields(gc, _("Add new domain"),
 657                               _("Add new domain"), NULL, fields,
 658                               _("Add"), G_CALLBACK(sipe_purple_ask_access_domain_cb),
 659                               _("Cancel"), NULL,
 660 #if PURPLE_VERSION_CHECK(3,0,0)
 661                               purple_request_cpar_from_account(account),
 662 #else
 663                               account, NULL, NULL,
 664 #endif
 665                               gc);
 666 }
 667
 668 static void sipe_purple_buddy_share_desktop_cb(SIPE_UNUSED_PARAMETER PurpleBuddy *buddy,
 669                                                SIPE_UNUSED_PARAMETER gpointer parameter)
 670 {
 671 #ifdef HAVE_APPSHARE_SERVER
 672         sipe_core_appshare_share_desktop(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 673                                          purple_buddy_get_name(buddy));
 674 #endif
 675 }
 676
 677 static void sipe_purple_buddy_give_desktop_control_cb(SIPE_UNUSED_PARAMETER PurpleBuddy *buddy,
 678                                                       SIPE_UNUSED_PARAMETER gpointer parameter)
 679 {
 680 #ifdef HAVE_APPSHARE_SERVER
 681         sipe_core_appshare_set_remote_control(parameter, TRUE);
 682 #endif
 683 }
 684
 685 static void sipe_purple_buddy_take_desktop_control_cb(SIPE_UNUSED_PARAMETER PurpleBuddy *buddy,
 686                                                       SIPE_UNUSED_PARAMETER gpointer parameter)
 687 {
 688 #ifdef HAVE_APPSHARE_SERVER
 689         sipe_core_appshare_set_remote_control(parameter, FALSE);
 690 #endif
 691 }
 692
 693 typedef void (*buddy_menu_callback)(PurpleBuddy *buddy,
 694                                     gpointer parameter);
 695 static const buddy_menu_callback callback_map[SIPE_BUDDY_MENU_TYPES] = {
 696 /* SIPE_BUDDY_MENU_MAKE_CHAT_LEADER    */ sipe_purple_buddy_make_chat_leader_cb,
 697 /* SIPE_BUDDY_MENU_REMOVE_FROM_CHAT    */ sipe_purple_buddy_remove_from_chat_cb,
 698 /* SIPE_BUDDY_MENU_INVITE_TO_CHAT      */ sipe_purple_buddy_invite_to_chat_cb,
 699 /* SIPE_BUDDY_MENU_NEW_CHAT            */ sipe_purple_buddy_new_chat_cb,
 700 /* SIPE_BUDDY_MENU_MAKE_CALL           */ sipe_purple_buddy_make_call_cb,
 701 /* SIPE_BUDDY_MENU_SEND_EMAIL          */ sipe_purple_buddy_send_email_cb,
 702 /* SIPE_BUDDY_MENU_ACCESS_LEVEL_HELP   */ sipe_purple_buddy_access_level_help_cb,
 703 /* SIPE_BUDDY_MENU_CHANGE_ACCESS_LEVEL */ sipe_purple_buddy_change_access_level_cb,
 704 /* SIPE_BUDDY_MENU_ADD_NEW_DOMAIN      */ sipe_purple_buddy_add_new_domain_cb,
 705 /* SIPE_BUDDY_MENU_SHARE_DESKTOP       */ sipe_purple_buddy_share_desktop_cb,
 706 /* SIPE_BUDDY_MENU_GIVE_DESKTOP_CONTROL*/ sipe_purple_buddy_give_desktop_control_cb,
 707 /* SIPE_BUDDY_MENU_TAKE_DESKTOP_CONTROL*/ sipe_purple_buddy_take_desktop_control_cb,
 708 };
 709
 710 struct sipe_backend_buddy_menu *sipe_backend_buddy_menu_start(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public)
 711 {
 712         return(NULL);
 713 }
 714
 715 struct sipe_backend_buddy_menu *sipe_backend_buddy_menu_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 716                                                             struct sipe_backend_buddy_menu *menu,
 717                                                             const gchar *label,
 718                                                             enum sipe_buddy_menu_type type,
 719                                                             gpointer parameter)
 720 {
 721         return((struct sipe_backend_buddy_menu *)
 722                g_list_prepend((GList *) menu,
 723                               purple_menu_action_new(label,
 724                                                      PURPLE_CALLBACK(callback_map[type]),
 725                                                      parameter, NULL)));
 726 }
 727
 728 struct sipe_backend_buddy_menu *sipe_backend_buddy_menu_separator(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 729                                                                   struct sipe_backend_buddy_menu *menu,
 730                                                                   const gchar *label)
 731 {
 732         return((struct sipe_backend_buddy_menu *)
 733                g_list_prepend((GList *) menu,
 734                               purple_menu_action_new(label, NULL, NULL, NULL)));
 735 }
 736
 737 struct sipe_backend_buddy_menu *sipe_backend_buddy_sub_menu_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 738                                                                 struct sipe_backend_buddy_menu *menu,
 739                                                                 const gchar *label,
 740                                                                 struct sipe_backend_buddy_menu *sub)
 741 {
 742         return((struct sipe_backend_buddy_menu *)
 743                g_list_prepend((GList *) menu,
 744                               purple_menu_action_new(label,
 745                                                      NULL,
 746                                                      NULL,
 747                                                      g_list_reverse((GList *) sub))));
 748 }
 749
 750 static void sipe_purple_buddy_copy_to_cb(PurpleBlistNode *node,
 751                                          const gchar *group_name)
 752 {
 753         struct sipe_core_public *sipe_public;
 754         PurpleBuddy *buddy = (PurpleBuddy *)node;
 755         PurpleGroup *group;
 756         PurpleBuddy *clone;
 757
 758         g_return_if_fail(PURPLE_IS_BUDDY(node));
 759
 760         sipe_public = PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC;
 761         group       = purple_blist_find_group(group_name);
 762
 763         SIPE_DEBUG_INFO("sipe_purple_buddy_copy_to_cb: copying %s to %s",
 764                         purple_buddy_get_name(buddy), group_name);
 765
 766         clone = purple_blist_find_buddy_in_group(purple_buddy_get_account(buddy),
 767                                                  purple_buddy_get_name(buddy),
 768                                                  group);
 769         if (!clone) {
 770                 clone = sipe_backend_buddy_add(sipe_public,
 771                                                purple_buddy_get_name(buddy),
 772 #if PURPLE_VERSION_CHECK(3,0,0)
 773                                                purple_buddy_get_local_alias(buddy),
 774 #else
 775                                                buddy->alias,
 776 #endif
 777                                                purple_group_get_name(group));
 778                 if (clone) {
 779                         const gchar *tmp;
 780                         const gchar *key;
 781                         const PurpleStatus *status = purple_presence_get_active_status(purple_buddy_get_presence(buddy));
 782
 783                         tmp = purple_buddy_get_server_alias(buddy);
 784                         if (tmp) purple_buddy_set_server_alias(clone, tmp);
 785
 786                         key = buddy_info_property(SIPE_BUDDY_INFO_EMAIL);
 787                         tmp = purple_blist_node_get_string(&buddy->node, key);
 788                         if (tmp) purple_blist_node_set_string(&clone->node,
 789                                                               key,
 790                                                               tmp);
 791
 792                         tmp = purple_status_get_id(status);
 793                         purple_presence_set_status_active(purple_buddy_get_presence(clone),
 794                                                           tmp,
 795                                                           TRUE);
 796
 797                         /* update UI */
 798                         purple_protocol_got_user_status(purple_buddy_get_account(clone),
 799                                                         purple_buddy_get_name(clone),
 800                                                         tmp,
 801                                                         SIPE_PURPLE_STATUS_ATTR_ID_MESSAGE, tmp,
 802                                                         NULL);
 803                 }
 804         }
 805
 806         if (clone && group)
 807                 sipe_core_buddy_add(sipe_public,
 808                                     purple_buddy_get_name(clone),
 809                                     purple_group_get_name(group));
 810 }
 811
 812 static GList *sipe_purple_copy_to_menu(GList *menu,
 813                                        PurpleBuddy *buddy)
 814 {
 815         GList *menu_groups = NULL;
 816         PurpleGroup *gr_parent = purple_buddy_get_group(buddy);
 817         PurpleBlistNode *g_node;
 818
 819         for (g_node = purple_blist_get_root(); g_node; g_node = g_node->next) {
 820                 PurpleGroup *group = (PurpleGroup *)g_node;
 821                 PurpleMenuAction *act;
 822
 823                 if ((!PURPLE_IS_GROUP(g_node)) ||
 824                     (group == gr_parent)       ||
 825                     purple_blist_find_buddy_in_group(purple_buddy_get_account(buddy),
 826                                                      purple_buddy_get_name(buddy),
 827                                                      group))
 828                         continue;
 829
 830                 act = purple_menu_action_new(purple_group_get_name(group),
 831                                              PURPLE_CALLBACK(sipe_purple_buddy_copy_to_cb),
 832                                              (gpointer) purple_group_get_name(group),
 833                                              NULL);
 834                 menu_groups = g_list_prepend(menu_groups, act);
 835         }
 836
 837         if (menu_groups)
 838                 menu = g_list_prepend(menu,
 839                                       purple_menu_action_new(_("Copy to"),
 840                                                              NULL,
 841                                                              NULL,
 842                                                              g_list_reverse(menu_groups)));
 843
 844         return(menu);
 845 }
 846
 847 GList *sipe_purple_buddy_menu(PurpleBuddy *buddy)
 848 {
 849         struct sipe_core_public *sipe_public = PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC;
 850         GList *menu = (GList *) sipe_core_buddy_create_menu(sipe_public,
 851                                                             purple_buddy_get_name(buddy),
 852                                                             NULL);
 853         menu = sipe_purple_copy_to_menu(menu, buddy);
 854         return(g_list_reverse(menu));
 855 }
 856
 857
 858 /*
 859   Local Variables:
 860   mode: c
 861   c-file-style: "bsd"
 862   indent-tabs-mode: t
 863   tab-width: 8
 864   End:
 865 */