src/purple/purple-buddy.c

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