webcit/roomlist.c

   1 /*
   2  * $Id: roomlist.c 7751 2009-08-28 21:13:28Z dothebart $
   3  * room listings and filters.
   4  */
   5
   6 #include "webcit.h"
   7 #include "webserver.h"
   8 #include "roomops.h"
   9
  10 void DeleteFloor(void *vFloor)
  11 {
  12         floor *Floor;
  13         Floor = (floor*) vFloor;
  14         FreeStrBuf(&Floor->Name);
  15         free(Floor);
  16 }
  17
  18 int SortFloorsByNameOrder(const void *vfloor1, const void *vfloor2)
  19 {
  20         floor *f1 = (floor*) GetSearchPayload(vfloor1);
  21         floor *f2 = (floor*) GetSearchPayload(vfloor2);
  22
  23         /* prefer My floor over alpabetical sort */
  24         if (f1->ID == VIRTUAL_MY_FLOOR)
  25                 return 1;
  26         if (f2->ID == VIRTUAL_MY_FLOOR)
  27                 return -1;
  28
  29         return strcmp(ChrPtr(f1->Name), ChrPtr(f2->Name));
  30 }
  31
  32 HashList *GetFloorListHash(StrBuf *Target, WCTemplputParams *TP) {
  33         const char *Err;
  34         StrBuf *Buf;
  35         HashList *floors;
  36         HashPos *it;
  37         floor *Floor;
  38         void *vFloor;
  39         const char *Pos;
  40         int i;
  41         wcsession *WCC = WC;
  42         const char *HashKey;
  43         long HKLen;
  44
  45
  46         if (WCC->Floors != NULL)
  47                 return WCC->Floors;
  48         WCC->Floors = floors = NewHash(1, NULL);
  49         Buf = NewStrBuf();
  50
  51         Floor = malloc(sizeof(floor));
  52         Floor->ID = VIRTUAL_MY_FLOOR;
  53         Floor->Name = NewStrBufPlain(_("My Folders"), -1);
  54         Floor->NRooms = 0;
  55
  56         Put(floors, IKEY(Floor->ID), Floor, DeleteFloor);
  57
  58         serv_puts("LFLR"); /* get floors */
  59         StrBufTCP_read_line(Buf, &WC->serv_sock, 0, &Err); /* '100', we hope */
  60         if (GetServerStatus(Buf, NULL) == 1)
  61         {
  62                 while(StrBufTCP_read_line(Buf, &WC->serv_sock, 0, &Err), strcmp(ChrPtr(Buf), "000"))
  63                 {
  64
  65                         Pos = NULL;
  66
  67                         Floor = malloc(sizeof(floor));
  68                         Floor->ID = StrBufExtractNext_long(Buf, &Pos, '|');
  69                         Floor->Name = NewStrBufPlain(NULL, StrLength(Buf));
  70                         StrBufExtract_NextToken(Floor->Name, Buf, &Pos, '|');
  71                         Floor->NRooms = StrBufExtractNext_long(Buf, &Pos, '|');
  72
  73                         Put(floors, IKEY(Floor->ID), Floor, DeleteFloor);
  74                 }
  75         }
  76         FreeStrBuf(&Buf);
  77
  78         /* now lets pre-sort them alphabeticaly. */
  79         i = 1;
  80         SortByPayload(floors, SortFloorsByNameOrder);
  81         it = GetNewHashPos(floors, 0);
  82         while ( GetNextHashPos(floors, it, &HKLen, &HashKey, &vFloor))
  83                 ((floor*) vFloor)->AlphaN = i++;
  84         DeleteHashPos(&it);
  85         SortByHashKeyStr(floors);
  86
  87         return floors;
  88 }
  89
  90 void tmplput_FLOOR_ID(StrBuf *Target, WCTemplputParams *TP)
  91 {
  92         floor *Floor = (floor *)(TP->Context);
  93
  94         StrBufAppendPrintf(Target, "%d", Floor->ID);
  95 }
  96
  97 void tmplput_FLOOR_NAME(StrBuf *Target, WCTemplputParams *TP)
  98 {
  99         floor *Floor = (floor *)(TP->Context);
 100
 101         StrBufAppendTemplate(Target, TP, Floor->Name, 0);
 102 }
 103
 104 void tmplput_FLOOR_NROOMS(StrBuf *Target, WCTemplputParams *TP)
 105 {
 106         floor *Floor = (floor *)(TP->Context);
 107
 108         StrBufAppendPrintf(Target, "%d", Floor->NRooms);
 109 }
 110 HashList *GetRoomListHashLKRA(StrBuf *Target, WCTemplputParams *TP)
 111 {
 112         wcsession *WCC = WC;
 113
 114         if (WCC->Floors == NULL)
 115                 GetFloorListHash(Target, TP);
 116         serv_puts("LKRA");
 117         return GetRoomListHash(Target, TP);
 118 }
 119
 120 void DeleteFolder(void *vFolder)
 121 {
 122         int i;
 123         folder *room;
 124         room = (folder*) vFolder;
 125
 126         FreeStrBuf(&room->name);
 127         FreeStrBuf(&room->ACL);
 128
 129         //// FreeStrBuf(&room->room);
 130
 131         if (room->RoomNameParts != NULL)
 132         {
 133                 for (i=0; i < room->nRoomNameParts; i++)
 134                         FreeStrBuf(&room->RoomNameParts[i]);
 135                 free(room->RoomNameParts);
 136         }
 137         free(room);
 138 }
 139
 140
 141 HashList *GetRoomListHash(StrBuf *Target, WCTemplputParams *TP)
 142 {
 143         HashList *rooms;
 144         folder *room;
 145         StrBuf *Buf;
 146         const char *Pos;
 147         const char *Err;
 148         void *vFloor;
 149         wcsession *WCC = WC;
 150         CompareFunc SortIt;
 151         WCTemplputParams SubTP;
 152
 153         Buf = NewStrBuf();
 154         rooms = NewHash(1, NULL);
 155         StrBufTCP_read_line(Buf, &WC->serv_sock, 0, &Err);
 156         if (GetServerStatus(Buf, NULL) == 1)
 157         {
 158                 while(StrBufTCP_read_line(Buf, &WC->serv_sock, 0, &Err),
 159                       strcmp(ChrPtr(Buf), "000"))
 160                 {
 161
 162                         Pos = NULL;
 163                         room = (folder*) malloc (sizeof(folder));
 164                         memset(room, 0, sizeof(folder));
 165
 166                         /* Load the base data from the server reply */
 167                         room->name = NewStrBufPlain(NULL, StrLength(Buf));
 168                         StrBufExtract_NextToken(room->name, Buf, &Pos, '|');
 169
 170                         room->QRFlags = StrBufExtractNext_long(Buf, &Pos, '|');
 171                         room->floorid = StrBufExtractNext_long(Buf, &Pos, '|');
 172
 173                         room->listorder = StrBufExtractNext_long(Buf, &Pos, '|');
 174
 175                         room->ACL = NewStrBufPlain(NULL, StrLength(Buf));
 176                         StrBufExtract_NextToken(room->ACL, Buf, &Pos, '|');
 177
 178                         room->view = StrBufExtractNext_long(Buf, &Pos, '|');
 179                         room->defview = StrBufExtractNext_long(Buf, &Pos, '|');
 180                         room->lastchange = StrBufExtractNext_long(Buf, &Pos, '|');
 181 /*
 182
 183                         /* Evaluate the Server sent data for later use */
 184                         /* find out, whether we are in a sub-room */
 185                         room->nRoomNameParts = StrBufNum_tokens(room->name, '\\');
 186                         if (room->nRoomNameParts > 1)
 187                         {
 188                                 int i;
 189
 190                                 Pos = NULL;
 191                                 room->RoomNameParts = malloc(sizeof(StrBuf*) * (room->nRoomNameParts + 1));
 192                                 memset(room->RoomNameParts, 0, sizeof(StrBuf*) * (room->nRoomNameParts + 1));
 193                                 for (i=0; i < room->nRoomNameParts; i++)
 194                                 {
 195                                         room->RoomNameParts[i] = NewStrBuf();
 196                                         StrBufExtract_NextToken(room->RoomNameParts[i],
 197                                                                 room->name, &Pos, '\\');
 198                                 }
 199                         }
 200
 201                         /* Private mailboxes on the main floor get remapped to the personal folder */
 202                         if ((room->QRFlags & QR_MAILBOX) &&
 203                             (room->floorid == 0))
 204                                 room->floorid = VIRTUAL_MY_FLOOR;
 205                         /* get a pointer to the floor we're on: */
 206                         GetHash(WCC->Floors, IKEY(room->floorid), &vFloor);
 207                         room->Floor = (const floor*) vFloor;
 208
 209
 210
 211                         /* now we know everything, remember it... */
 212                         Put(rooms, SKEY(room->name), room, DeleteFolder);
 213                 }
 214         }
 215 ///     SortByHashKey(rooms, 1);
 216
 217         SubTP.Filter.ContextType = CTX_ROOMS;
 218         SortIt = RetrieveSort(&SubTP, NULL, 0, HKEY("fileunsorted"), 0);
 219         if (SortIt != NULL)
 220                 SortByPayload(rooms, SortIt);
 221         else
 222                 SortByPayload(rooms, SortRoomsByListOrder);
 223         FreeStrBuf(&Buf);
 224         return rooms;
 225 }
 226
 227 /** Unused function that orders rooms by the listorder flag */
 228 int SortRoomsByListOrder(const void *room1, const void *room2)
 229 {
 230         folder *r1 = (folder*) GetSearchPayload(room1);
 231         folder *r2 = (folder*) GetSearchPayload(room2);
 232
 233         if (r1->listorder == r2->listorder) return 0;
 234         if (r1->listorder > r2->listorder) return 1;
 235         return -1;
 236 }
 237
 238 int CompareRoomListByFloorRoomPrivFirst(const void *room1, const void *room2)
 239 {
 240         folder *r1 = (folder*) GetSearchPayload(room1);
 241         folder *r2 = (folder*) GetSearchPayload(room2);
 242
 243         /**
 244          * are we on the same floor? else sort by floor.
 245          */
 246         if (r1->Floor != r2->Floor)
 247         {
 248                 /**
 249                  * the private rooms are first in any case.
 250                  */
 251                 if (r1->Floor->ID == VIRTUAL_MY_FLOOR)
 252                         return -1;
 253                 if (r2->Floor->ID == VIRTUAL_MY_FLOOR)
 254                         return 1;
 255                 /**
 256                  * else decide alpaheticaly by floorname
 257                  */
 258                 return (r1->Floor->AlphaN > r2->Floor->AlphaN)? 1 : -1;
 259         }
 260
 261         /**
 262          * if we have different levels of subdirectories,
 263          * we want the toplevel to be first, regardless of sort
 264          * sequence.
 265          */
 266         if (((r1->nRoomNameParts > 1) ||
 267             (r2->nRoomNameParts > 1)    )&&
 268             (r1->nRoomNameParts != r2->nRoomNameParts))
 269         {
 270                 int i, ret;
 271                 int nparts = (r1->nRoomNameParts > r2->nRoomNameParts)?
 272                         r2->nRoomNameParts : r1->nRoomNameParts;
 273
 274                 for (i=0; i < nparts; i++)
 275                 {
 276                         ret = strcmp (ChrPtr(r1->name),
 277                                       ChrPtr(r2->name));
 278                         /**
 279                          * Deltas in common parts? exit here.
 280                          */
 281                         if (ret != 0)
 282                                 return ret;
 283                 }
 284
 285                 /**
 286                  * who's a subdirectory of whom?
 287                  */
 288                 if (r1->nRoomNameParts > r2->nRoomNameParts)
 289                         return 1;
 290                 else
 291                         return -1;
 292
 293         }
 294
 295         /**
 296          * else just sort alphabeticaly.
 297          */
 298         return strcmp (ChrPtr(r1->name),
 299                        ChrPtr(r2->name));
 300 }
 301
 302 int CompareRoomListByFloorRoomPrivFirstRev(const void *room1, const void *room2)
 303 {
 304         folder *r1 = (folder*) GetSearchPayload(room1);
 305         folder *r2 = (folder*) GetSearchPayload(room2);
 306
 307         /**
 308          * are we on the same floor? else sort by floor.
 309          */
 310         if (r2->Floor != r1->Floor)
 311         {
 312                 /**
 313                  * the private rooms are first in any case.
 314                  */
 315                 if (r1->Floor->ID == VIRTUAL_MY_FLOOR)
 316                         return -1;
 317                 if (r2->Floor->ID == VIRTUAL_MY_FLOOR)
 318                         return 1;
 319                 /**
 320                  * else decide alpaheticaly by floorname
 321                  */
 322
 323                 return (r1->Floor->AlphaN < r2->Floor->AlphaN)? 1 : -1;
 324         }
 325
 326         /**
 327          * if we have different levels of subdirectories,
 328          * we want the toplevel to be first, regardless of sort
 329          * sequence.
 330          */
 331         if (((r1->nRoomNameParts > 1) ||
 332             (r2->nRoomNameParts > 1)    )&&
 333             (r1->nRoomNameParts != r2->nRoomNameParts))
 334         {
 335                 int i, ret;
 336                 int nparts = (r1->nRoomNameParts > r2->nRoomNameParts)?
 337                         r2->nRoomNameParts : r1->nRoomNameParts;
 338
 339                 for (i=0; i < nparts; i++)
 340                 {
 341                         /**
 342                          * special cases if one room is top-level...
 343                          */
 344                         if (r2->nRoomNameParts == 1)
 345                                 ret = strcmp (ChrPtr(r2->name),
 346                                               ChrPtr(r1->RoomNameParts[i]));
 347                         else if (r1->nRoomNameParts == 1)
 348                                 ret = strcmp (ChrPtr(r2->RoomNameParts[i]),
 349                                               ChrPtr(r1->name));
 350                         else
 351                                 ret = strcmp (ChrPtr(r2->RoomNameParts[i]),
 352                                               ChrPtr(r1->RoomNameParts[i]));
 353                         /**
 354                          * Deltas in common parts? exit here.
 355                          */
 356                         if (ret != 0)
 357                                 return ret;
 358                 }
 359
 360                 /**
 361                  * who's a subdirectory of whom?
 362                  */
 363                 if (r1->nRoomNameParts > r2->nRoomNameParts)
 364                         return 1;
 365                 else
 366                         return -1;
 367         }
 368
 369         return strcmp (ChrPtr(r2->name),
 370                        ChrPtr(r1->name));
 371 }
 372
 373 int GroupchangeRoomListByFloorRoomPrivFirst(const void *room1, const void *room2)
 374 {
 375         folder *r1 = (folder*) room1;
 376         folder *r2 = (folder*) room2;
 377
 378
 379         if (r1->Floor == r2->Floor)
 380                 return 0;
 381         else
 382         {
 383                 wcsession *WCC = WC;
 384                 static int columns = 3;
 385                 int boxes_per_column = 0;
 386                 int nf;
 387
 388                 nf = GetCount(WCC->Floors);
 389                 while (nf % columns != 0) ++nf;
 390                 boxes_per_column = (nf / columns);
 391                 if (boxes_per_column < 1)
 392                         boxes_per_column = 1;
 393                 if (r1->Floor->AlphaN % boxes_per_column == 0)
 394                         return 2;
 395                 else
 396                         return 1;
 397 ///                                     wprintf("</td><td valign=top>\n");
 398         }
 399 }
 400
 401
 402
 403
 404
 405
 406 void tmplput_ROOM_NAME(StrBuf *Target, WCTemplputParams *TP)
 407 {
 408         folder *Folder = (folder *)(TP->Context);
 409
 410         StrBufAppendTemplate(Target, TP, Folder->name, 0);
 411 }
 412 void tmplput_ROOM_BASENAME(StrBuf *Target, WCTemplputParams *TP)
 413 {
 414         folder *room = (folder *)(TP->Context);
 415
 416         if (room->nRoomNameParts > 1)
 417                 StrBufAppendTemplate(Target, TP,
 418                                       room->RoomNameParts[room->nRoomNameParts - 1], 0);
 419         else
 420                 StrBufAppendTemplate(Target, TP, room->name, 0);
 421 }
 422 void tmplput_ROOM_LEVEL_N_TIMES(StrBuf *Target, WCTemplputParams *TP)
 423 {
 424         folder *room = (folder *)(TP->Context);
 425         int i;
 426         const char *AppendMe;
 427         long AppendMeLen;
 428
 429
 430         if (room->nRoomNameParts > 1)
 431         {
 432                 GetTemplateTokenString(Target, TP, 0, &AppendMe, &AppendMeLen);
 433                 for (i = 0; i < room->nRoomNameParts; i++)
 434                         StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0);
 435         }
 436 }
 437
 438 void tmplput_ROOM_ACL(StrBuf *Target, WCTemplputParams *TP)
 439 {
 440         folder *Folder = (folder *)(TP->Context);
 441
 442         StrBufAppendTemplate(Target, TP, Folder->ACL, 0);
 443 }
 444
 445
 446 void tmplput_ROOM_QRFLAGS(StrBuf *Target, WCTemplputParams *TP)
 447 {
 448         folder *Folder = (folder *)(TP->Context);
 449         StrBufAppendPrintf(Target, "%d", Folder->QRFlags);
 450 }
 451
 452
 453
 454 void tmplput_ROOM_FLOORID(StrBuf *Target, WCTemplputParams *TP)
 455 {
 456         folder *Folder = (folder *)(TP->Context);
 457         StrBufAppendPrintf(Target, "%d", Folder->floorid);
 458 }
 459
 460 void tmplput_ROOM_LISTORDER(StrBuf *Target, WCTemplputParams *TP)
 461 {
 462         folder *Folder = (folder *)(TP->Context);
 463         StrBufAppendPrintf(Target, "%d", Folder->listorder);
 464 }
 465 void tmplput_ROOM_VIEW(StrBuf *Target, WCTemplputParams *TP)
 466 {
 467         folder *Folder = (folder *)(TP->Context);
 468         StrBufAppendPrintf(Target, "%d", Folder->view);
 469 }
 470 void tmplput_ROOM_DEFVIEW(StrBuf *Target, WCTemplputParams *TP)
 471 {
 472         folder *Folder = (folder *)(TP->Context);
 473         StrBufAppendPrintf(Target, "%d", Folder->defview);
 474 }
 475 void tmplput_ROOM_LASTCHANGE(StrBuf *Target, WCTemplputParams *TP)
 476 {
 477         folder *Folder = (folder *)(TP->Context);
 478         StrBufAppendPrintf(Target, "%d", Folder->lastchange);
 479 }
 480 void tmplput_ROOM_FLOOR_ID(StrBuf *Target, WCTemplputParams *TP)
 481 {
 482         folder *Folder = (folder *)(TP->Context);
 483         const floor *Floor = Folder->Floor;
 484
 485         if (Floor == NULL)
 486                 return;
 487
 488         StrBufAppendPrintf(Target, "%d", Floor->ID);
 489 }
 490
 491 void tmplput_ROOM_FLOOR_NAME(StrBuf *Target, WCTemplputParams *TP)
 492 {
 493         folder *Folder = (folder *)(TP->Context);
 494         const floor *Floor = Folder->Floor;
 495
 496         if (Floor == NULL)
 497                 return;
 498
 499         StrBufAppendTemplate(Target, TP, Floor->Name, 0);
 500 }
 501
 502 void tmplput_ROOM_FLOOR_NROOMS(StrBuf *Target, WCTemplputParams *TP)
 503 {
 504         folder *Folder = (folder *)(TP->Context);
 505         const floor *Floor = Folder->Floor;
 506
 507         if (Floor == NULL)
 508                 return;
 509         StrBufAppendPrintf(Target, "%d", Floor->NRooms);
 510 }
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525 void jsonRoomFlr(void)
 526 {
 527         /* Send as our own (application/json) content type */
 528         hprintf("HTTP/1.1 200 OK\r\n");
 529         hprintf("Content-type: application/json; charset=utf-8\r\n");
 530         hprintf("Server: %s / %s\r\n", PACKAGE_STRING, ChrPtr(WC->serv_info->serv_software));
 531         hprintf("Connection: close\r\n");
 532         hprintf("Pragma: no-cache\r\nCache-Control: no-store\r\nExpires:-1\r\n");
 533         begin_burst();
 534         DoTemplate(HKEY("json_roomflr"),NULL,&NoCtx);
 535         end_burst();
 536 }
 537
 538
 539
 540 void
 541 InitModule_ROOMLIST
 542 (void)
 543 {
 544         WebcitAddUrlHandler(HKEY("json_roomflr"), jsonRoomFlr, 0);
 545
 546
 547         RegisterNamespace("FLOOR:ID", 0, 0, tmplput_FLOOR_ID, CTX_FLOORS);
 548         RegisterNamespace("FLOOR:NAME", 0, 1, tmplput_FLOOR_NAME, CTX_FLOORS);
 549         RegisterNamespace("FLOOR:NROOMS", 0, 0, tmplput_FLOOR_NROOMS, CTX_FLOORS);
 550
 551
 552
 553         RegisterIterator("LKRA", 0, NULL, GetRoomListHashLKRA, NULL, DeleteHash, CTX_ROOMS, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 554
 555         RegisterNamespace("ROOM:INFO:FLOORID", 0, 1, tmplput_ROOM_FLOORID, CTX_ROOMS);
 556         RegisterNamespace("ROOM:INFO:NAME", 0, 1, tmplput_ROOM_NAME, CTX_ROOMS);
 557         RegisterNamespace("ROOM:INFO:BASENAME", 0, 1, tmplput_ROOM_BASENAME, CTX_ROOMS);
 558         RegisterNamespace("ROOM:INFO:LEVELNTIMES", 1, 2, tmplput_ROOM_LEVEL_N_TIMES, CTX_ROOMS);
 559
 560         RegisterNamespace("ROOM:INFO:ACL", 0, 1, tmplput_ROOM_ACL, CTX_ROOMS);
 561         RegisterNamespace("ROOM:INFO:QRFLAGS", 0, 1, tmplput_ROOM_QRFLAGS, CTX_ROOMS);
 562         RegisterNamespace("ROOM:INFO:LISTORDER", 0, 1, tmplput_ROOM_LISTORDER, CTX_ROOMS);
 563         RegisterNamespace("ROOM:INFO:VIEW", 0, 1, tmplput_ROOM_VIEW, CTX_ROOMS);
 564         RegisterNamespace("ROOM:INFO:DEFVIEW", 0, 1, tmplput_ROOM_DEFVIEW, CTX_ROOMS);
 565         RegisterNamespace("ROOM:INFO:LASTCHANGE", 0, 1, tmplput_ROOM_LASTCHANGE, CTX_ROOMS);
 566         RegisterNamespace("ROOM:INFO:FLOOR:ID", 0, 0, tmplput_ROOM_FLOOR_ID, CTX_ROOMS);
 567         RegisterNamespace("ROOM:INFO:FLOOR:NAME", 0, 1, tmplput_ROOM_FLOOR_NAME, CTX_ROOMS);
 568         RegisterNamespace("ROOM:INFO:FLOOR:NROOMS", 0, 0, tmplput_ROOM_FLOOR_NROOMS, CTX_ROOMS);
 569
 570         RegisterSortFunc(HKEY("byfloorroom"),
 571                          NULL, 0,
 572                          CompareRoomListByFloorRoomPrivFirst,
 573                          CompareRoomListByFloorRoomPrivFirstRev,
 574                          GroupchangeRoomListByFloorRoomPrivFirst,
 575                          CTX_ROOMS);
 576
 577 }