src/core/sipe-group.c

   1 /**
   2  * @file sipe-group.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2011 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 "sipmsg.h"
  30 #include "sip-soap.h"
  31 #include "sip-transport.h"
  32 #include "sipe-backend.h"
  33 #include "sipe-buddy.h"
  34 #include "sipe-core.h"
  35 #include "sipe-core-private.h"
  36 #include "sipe-group.h"
  37 #include "sipe-nls.h"
  38 #include "sipe-utils.h"
  39 #include "sipe-xml.h"
  40
  41 struct group_user_context {
  42         gchar *group_name;
  43         gchar *user_name;
  44 };
  45
  46 static void
  47 sipe_group_context_destroy(gpointer data)
  48 {
  49         struct group_user_context *ctx = data;
  50         g_free(ctx->group_name);
  51         g_free(ctx->user_name);
  52         g_free(ctx);
  53 }
  54
  55 static gboolean
  56 process_add_group_response(struct sipe_core_private *sipe_private,
  57                            struct sipmsg *msg,
  58                            struct transaction *trans)
  59 {
  60         if (msg->response == 200) {
  61                 struct sipe_group *group;
  62                 struct group_user_context *ctx = trans->payload->data;
  63                 sipe_xml *xml;
  64                 const sipe_xml *node;
  65                 char *group_id;
  66                 struct sipe_buddy *buddy;
  67
  68                 xml = sipe_xml_parse(msg->body, msg->bodylen);
  69                 if (!xml) {
  70                         return FALSE;
  71                 }
  72
  73                 node = sipe_xml_child(xml, "Body/addGroup/groupID");
  74                 if (!node) {
  75                         sipe_xml_free(xml);
  76                         return FALSE;
  77                 }
  78
  79                 group_id = sipe_xml_data(node);
  80                 if (!group_id) {
  81                         sipe_xml_free(xml);
  82                         return FALSE;
  83                 }
  84
  85                 group = g_new0(struct sipe_group, 1);
  86                 group->id = (int)g_ascii_strtod(group_id, NULL);
  87                 g_free(group_id);
  88                 group->name = g_strdup(ctx->group_name);
  89
  90                 sipe_group_add(sipe_private, group);
  91
  92                 if (ctx->user_name) {
  93                         buddy = g_hash_table_lookup(sipe_private->buddies, ctx->user_name);
  94                         if (buddy) {
  95                                 buddy->groups = slist_insert_unique_sorted(buddy->groups, group, (GCompareFunc)sipe_group_compare);
  96                         }
  97
  98                         sipe_core_group_set_user(SIPE_CORE_PUBLIC, ctx->user_name);
  99                 }
 100
 101                 sipe_xml_free(xml);
 102                 return TRUE;
 103         }
 104         return FALSE;
 105 }
 106
 107 int
 108 sipe_group_compare(struct sipe_group *group1, struct sipe_group *group2) {
 109         return group1->id - group2->id;
 110 }
 111
 112 struct sipe_group*
 113 sipe_group_find_by_id(struct sipe_core_private *sipe_private,
 114                       int id)
 115 {
 116         struct sipe_group *group;
 117         GSList *entry;
 118
 119         if (!sipe_private)
 120                 return NULL;
 121
 122         entry = sipe_private->groups;
 123         while (entry) {
 124                 group = entry->data;
 125                 if (group->id == id) {
 126                         return group;
 127                 }
 128                 entry = entry->next;
 129         }
 130         return NULL;
 131 }
 132
 133 struct sipe_group*
 134 sipe_group_find_by_name(struct sipe_core_private *sipe_private,
 135                         const gchar * name)
 136 {
 137         struct sipe_group *group;
 138         GSList *entry;
 139
 140         if (!sipe_private || !name)
 141                 return NULL;
 142
 143         entry = sipe_private->groups;
 144         while (entry) {
 145                 group = entry->data;
 146                 if (sipe_strequal(group->name, name)) {
 147                         return group;
 148                 }
 149                 entry = entry->next;
 150         }
 151         return NULL;
 152 }
 153
 154 void
 155 sipe_group_create(struct sipe_core_private *sipe_private,
 156                   const gchar *name,
 157                   const gchar *who)
 158 {
 159         struct transaction_payload *payload = g_new0(struct transaction_payload, 1);
 160         struct group_user_context *ctx = g_new0(struct group_user_context, 1);
 161         const gchar *soap_name = sipe_strequal(name, _("Other Contacts")) ? "~" : name;
 162         gchar *request;
 163         ctx->group_name = g_strdup(name);
 164         ctx->user_name = g_strdup(who);
 165         payload->destroy = sipe_group_context_destroy;
 166         payload->data = ctx;
 167
 168         /* soap_name can contain restricted characters */
 169         request = g_markup_printf_escaped("<m:name>%s</m:name>"
 170                                           "<m:externalURI />",
 171                                           soap_name);
 172         sip_soap_request_cb(sipe_private,
 173                             "addGroup",
 174                             request,
 175                             process_add_group_response,
 176                             payload);
 177         g_free(request);
 178 }
 179
 180 void
 181 sipe_group_add(struct sipe_core_private *sipe_private,
 182                struct sipe_group * group)
 183 {
 184         if (sipe_backend_buddy_group_add(SIPE_CORE_PUBLIC,group->name))
 185         {
 186                 SIPE_DEBUG_INFO("added group %s (id %d)", group->name, group->id);
 187                 sipe_private->groups = g_slist_append(sipe_private->groups,
 188                                                       group);
 189         }
 190         else
 191         {
 192                 SIPE_DEBUG_INFO("did not add group %s", group->name ? group->name : "");
 193         }
 194 }
 195
 196 void
 197 sipe_core_group_rename(struct sipe_core_public *sipe_public,
 198                        const gchar *old_name,
 199                        const gchar *new_name)
 200 {
 201         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 202         struct sipe_group *s_group = sipe_group_find_by_name(sipe_private, old_name);
 203
 204         if (s_group) {
 205                 gchar *request;
 206                 SIPE_DEBUG_INFO("Renaming group %s to %s", old_name, new_name);
 207                 /* new_name can contain restricted characters */
 208                 request = g_markup_printf_escaped("<m:groupID>%d</m:groupID>"
 209                                                   "<m:name>%s</m:name>"
 210                                                   "<m:externalURI />",
 211                                                   s_group->id, new_name);
 212                 sip_soap_request(sipe_private,
 213                                  "modifyGroup",
 214                                  request);
 215                 g_free(request);
 216
 217                 g_free(s_group->name);
 218                 s_group->name = g_strdup(new_name);
 219         } else {
 220                 SIPE_DEBUG_INFO("Cannot find group %s to rename", old_name);
 221         }
 222 }
 223
 224 void
 225 sipe_core_group_remove(struct sipe_core_public *sipe_public,
 226                        const gchar *name)
 227 {
 228         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 229         struct sipe_group *s_group = sipe_group_find_by_name(sipe_private, name);
 230
 231         if (s_group) {
 232                 gchar *request;
 233                 SIPE_DEBUG_INFO("Deleting group %s", name);
 234                 request = g_strdup_printf("<m:groupID>%d</m:groupID>",
 235                                           s_group->id);
 236                 sip_soap_request(sipe_private,
 237                                  "deleteGroup",
 238                                  request);
 239                 g_free(request);
 240
 241                 sipe_private->groups = g_slist_remove(sipe_private->groups,
 242                                                       s_group);
 243                 g_free(s_group->name);
 244                 g_free(s_group);
 245         } else {
 246                 SIPE_DEBUG_INFO("Cannot find group %s to delete", name);
 247         }
 248 }
 249
 250 /**
 251  * Returns string like "2 4 7 8" - group ids buddy belong to.
 252  */
 253 static gchar *sipe_get_buddy_groups_string(struct sipe_buddy *buddy)
 254 {
 255         int i = 0;
 256         gchar *res;
 257         //creating array from GList, converting int to gchar*
 258         gchar **ids_arr = g_new(gchar *, g_slist_length(buddy->groups) + 1);
 259         GSList *entry = buddy->groups;
 260
 261         if (!ids_arr) return NULL;
 262
 263         while (entry) {
 264                 struct sipe_group * group = entry->data;
 265                 ids_arr[i] = g_strdup_printf("%d", group->id);
 266                 entry = entry->next;
 267                 i++;
 268         }
 269         ids_arr[i] = NULL;
 270         res = g_strjoinv(" ", ids_arr);
 271         g_strfreev(ids_arr);
 272         return res;
 273 }
 274
 275 /**
 276  * Sends buddy update to server
 277  */
 278 void sipe_core_group_set_user(struct sipe_core_public *sipe_public,
 279                               const gchar *who)
 280 {
 281         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 282         struct sipe_buddy *buddy = g_hash_table_lookup(sipe_private->buddies, who);
 283         sipe_backend_buddy backend_buddy = sipe_backend_buddy_find(sipe_public, who, NULL);
 284
 285         if (buddy && backend_buddy) {
 286                 gchar *alias = sipe_backend_buddy_get_alias(sipe_public, backend_buddy);
 287                 gchar *groups = sipe_get_buddy_groups_string(buddy);
 288                 if (groups) {
 289                         gchar *request;
 290                         SIPE_DEBUG_INFO("Saving buddy %s with alias %s and groups %s", who, alias, groups);
 291
 292                         /* alias can contain restricted characters */
 293                         request = g_markup_printf_escaped("<m:displayName>%s</m:displayName>"
 294                                                           "<m:groups>%s</m:groups>"
 295                                                           "<m:subscribed>true</m:subscribed>"
 296                                                           "<m:URI>%s</m:URI>"
 297                                                           "<m:externalURI />",
 298                                                           alias, groups, buddy->name);
 299                         sip_soap_request(sipe_private,
 300                                          "setContact",
 301                                          request);
 302                         g_free(request);
 303                 }
 304                 g_free(alias);
 305         }
 306 }
 307
 308 /*
 309   Local Variables:
 310   mode: c
 311   c-file-style: "bsd"
 312   indent-tabs-mode: t
 313   tab-width: 8
 314   End:
 315 */