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         if ((r1->Floor == NULL)  ||
 244             (r2->Floor == NULL))
 245                 return 0;
 246
 247         /**
 248          * are we on the same floor? else sort by floor.
 249          */
 250         if (r1->Floor != r2->Floor)
 251         {
 252                 /**
 253                  * the private rooms are first in any case.
 254                  */
 255                 if (r1->Floor->ID == VIRTUAL_MY_FLOOR)
 256                         return -1;
 257                 if (r2->Floor->ID == VIRTUAL_MY_FLOOR)
 258                         return 1;
 259                 /**
 260                  * else decide alpaheticaly by floorname
 261                  */
 262                 return (r1->Floor->AlphaN > r2->Floor->AlphaN)? 1 : -1;
 263         }
 264
 265         /**
 266          * if we have different levels of subdirectories,
 267          * we want the toplevel to be first, regardless of sort
 268          * sequence.
 269          */
 270         if (((r1->nRoomNameParts > 1) ||
 271             (r2->nRoomNameParts > 1)    )&&
 272             (r1->nRoomNameParts != r2->nRoomNameParts))
 273         {
 274                 int i, ret;
 275                 int nparts = (r1->nRoomNameParts > r2->nRoomNameParts)?
 276                         r2->nRoomNameParts : r1->nRoomNameParts;
 277
 278                 for (i=0; i < nparts; i++)
 279                 {
 280                         ret = strcmp (ChrPtr(r1->name),
 281                                       ChrPtr(r2->name));
 282                         /**
 283                          * Deltas in common parts? exit here.
 284                          */
 285                         if (ret != 0)
 286                                 return ret;
 287                 }
 288
 289                 /**
 290                  * who's a subdirectory of whom?
 291                  */
 292                 if (r1->nRoomNameParts > r2->nRoomNameParts)
 293                         return 1;
 294                 else
 295                         return -1;
 296
 297         }
 298
 299         /**
 300          * else just sort alphabeticaly.
 301          */
 302         return strcmp (ChrPtr(r1->name),
 303                        ChrPtr(r2->name));
 304 }
 305
 306 int CompareRoomListByFloorRoomPrivFirstRev(const void *room1, const void *room2)
 307 {
 308         folder *r1 = (folder*) GetSearchPayload(room1);
 309         folder *r2 = (folder*) GetSearchPayload(room2);
 310
 311         if ((r1->Floor == NULL)  ||
 312             (r2->Floor == NULL))
 313                 return 0;
 314
 315         /**
 316          * are we on the same floor? else sort by floor.
 317          */
 318         if (r2->Floor != r1->Floor)
 319         {
 320                 /**
 321                  * the private rooms are first in any case.
 322                  */
 323                 if (r1->Floor->ID == VIRTUAL_MY_FLOOR)
 324                         return -1;
 325                 if (r2->Floor->ID == VIRTUAL_MY_FLOOR)
 326                         return 1;
 327                 /**
 328                  * else decide alpaheticaly by floorname
 329                  */
 330
 331                 return (r1->Floor->AlphaN < r2->Floor->AlphaN)? 1 : -1;
 332         }
 333
 334         /**
 335          * if we have different levels of subdirectories,
 336          * we want the toplevel to be first, regardless of sort
 337          * sequence.
 338          */
 339         if (((r1->nRoomNameParts > 1) ||
 340             (r2->nRoomNameParts > 1)    )&&
 341             (r1->nRoomNameParts != r2->nRoomNameParts))
 342         {
 343                 int i, ret;
 344                 int nparts = (r1->nRoomNameParts > r2->nRoomNameParts)?
 345                         r2->nRoomNameParts : r1->nRoomNameParts;
 346
 347                 for (i=0; i < nparts; i++)
 348                 {
 349                         /**
 350                          * special cases if one room is top-level...
 351                          */
 352                         if (r2->nRoomNameParts == 1)
 353                                 ret = strcmp (ChrPtr(r2->name),
 354                                               ChrPtr(r1->RoomNameParts[i]));
 355                         else if (r1->nRoomNameParts == 1)
 356                                 ret = strcmp (ChrPtr(r2->RoomNameParts[i]),
 357                                               ChrPtr(r1->name));
 358                         else
 359                                 ret = strcmp (ChrPtr(r2->RoomNameParts[i]),
 360                                               ChrPtr(r1->RoomNameParts[i]));
 361                         /**
 362                          * Deltas in common parts? exit here.
 363                          */
 364                         if (ret != 0)
 365                                 return ret;
 366                 }
 367
 368                 /**
 369                  * who's a subdirectory of whom?
 370                  */
 371                 if (r1->nRoomNameParts > r2->nRoomNameParts)
 372                         return 1;
 373                 else
 374                         return -1;
 375         }
 376
 377         return strcmp (ChrPtr(r2->name),
 378                        ChrPtr(r1->name));
 379 }
 380
 381 int GroupchangeRoomListByFloorRoomPrivFirst(const void *room1, const void *room2)
 382 {
 383         folder *r1 = (folder*) room1;
 384         folder *r2 = (folder*) room2;
 385
 386
 387         if ((r1->Floor == NULL)  ||
 388             (r2->Floor == NULL))
 389                 return 0;
 390
 391         if (r1->Floor == r2->Floor)
 392                 return 0;
 393         else
 394         {
 395                 wcsession *WCC = WC;
 396                 static int columns = 3;
 397                 int boxes_per_column = 0;
 398                 int nf;
 399
 400                 nf = GetCount(WCC->Floors);
 401                 while (nf % columns != 0) ++nf;
 402                 boxes_per_column = (nf / columns);
 403                 if (boxes_per_column < 1)
 404                         boxes_per_column = 1;
 405                 if (r1->Floor->AlphaN % boxes_per_column == 0)
 406                         return 2;
 407                 else
 408                         return 1;
 409 ///                                     wprintf("</td><td valign=top>\n");
 410         }
 411 }
 412
 413
 414
 415
 416
 417
 418 void tmplput_ROOM_NAME(StrBuf *Target, WCTemplputParams *TP)
 419 {
 420         folder *Folder = (folder *)(TP->Context);
 421
 422         StrBufAppendTemplate(Target, TP, Folder->name, 0);
 423 }
 424 void tmplput_ROOM_BASENAME(StrBuf *Target, WCTemplputParams *TP)
 425 {
 426         folder *room = (folder *)(TP->Context);
 427
 428         if (room->nRoomNameParts > 1)
 429                 StrBufAppendTemplate(Target, TP,
 430                                       room->RoomNameParts[room->nRoomNameParts - 1], 0);
 431         else
 432                 StrBufAppendTemplate(Target, TP, room->name, 0);
 433 }
 434 void tmplput_ROOM_LEVEL_N_TIMES(StrBuf *Target, WCTemplputParams *TP)
 435 {
 436         folder *room = (folder *)(TP->Context);
 437         int i;
 438         const char *AppendMe;
 439         long AppendMeLen;
 440
 441
 442         if (room->nRoomNameParts > 1)
 443         {
 444                 GetTemplateTokenString(Target, TP, 0, &AppendMe, &AppendMeLen);
 445                 for (i = 0; i < room->nRoomNameParts; i++)
 446                         StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0);
 447         }
 448 }
 449
 450 void tmplput_ROOM_ACL(StrBuf *Target, WCTemplputParams *TP)
 451 {
 452         folder *Folder = (folder *)(TP->Context);
 453
 454         StrBufAppendTemplate(Target, TP, Folder->ACL, 0);
 455 }
 456
 457
 458 void tmplput_ROOM_QRFLAGS(StrBuf *Target, WCTemplputParams *TP)
 459 {
 460         folder *Folder = (folder *)(TP->Context);
 461         StrBufAppendPrintf(Target, "%d", Folder->QRFlags);
 462 }
 463
 464
 465
 466 void tmplput_ROOM_FLOORID(StrBuf *Target, WCTemplputParams *TP)
 467 {
 468         folder *Folder = (folder *)(TP->Context);
 469         StrBufAppendPrintf(Target, "%d", Folder->floorid);
 470 }
 471
 472 void tmplput_ROOM_LISTORDER(StrBuf *Target, WCTemplputParams *TP)
 473 {
 474         folder *Folder = (folder *)(TP->Context);
 475         StrBufAppendPrintf(Target, "%d", Folder->listorder);
 476 }
 477 void tmplput_ROOM_VIEW(StrBuf *Target, WCTemplputParams *TP)
 478 {
 479         folder *Folder = (folder *)(TP->Context);
 480         StrBufAppendPrintf(Target, "%d", Folder->view);
 481 }
 482 void tmplput_ROOM_DEFVIEW(StrBuf *Target, WCTemplputParams *TP)
 483 {
 484         folder *Folder = (folder *)(TP->Context);
 485         StrBufAppendPrintf(Target, "%d", Folder->defview);
 486 }
 487 void tmplput_ROOM_LASTCHANGE(StrBuf *Target, WCTemplputParams *TP)
 488 {
 489         folder *Folder = (folder *)(TP->Context);
 490         StrBufAppendPrintf(Target, "%d", Folder->lastchange);
 491 }
 492 void tmplput_ROOM_FLOOR_ID(StrBuf *Target, WCTemplputParams *TP)
 493 {
 494         folder *Folder = (folder *)(TP->Context);
 495         const floor *Floor = Folder->Floor;
 496
 497         if (Floor == NULL)
 498                 return;
 499
 500         StrBufAppendPrintf(Target, "%d", Floor->ID);
 501 }
 502
 503 void tmplput_ROOM_FLOOR_NAME(StrBuf *Target, WCTemplputParams *TP)
 504 {
 505         folder *Folder = (folder *)(TP->Context);
 506         const floor *Floor = Folder->Floor;
 507
 508         if (Floor == NULL)
 509                 return;
 510
 511         StrBufAppendTemplate(Target, TP, Floor->Name, 0);
 512 }
 513
 514 void tmplput_ROOM_FLOOR_NROOMS(StrBuf *Target, WCTemplputParams *TP)
 515 {
 516         folder *Folder = (folder *)(TP->Context);
 517         const floor *Floor = Folder->Floor;
 518
 519         if (Floor == NULL)
 520                 return;
 521         StrBufAppendPrintf(Target, "%d", Floor->NRooms);
 522 }
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537 void jsonRoomFlr(void)
 538 {
 539         /* Send as our own (application/json) content type */
 540         hprintf("HTTP/1.1 200 OK\r\n");
 541         hprintf("Content-type: application/json; charset=utf-8\r\n");
 542         hprintf("Server: %s / %s\r\n", PACKAGE_STRING, ChrPtr(WC->serv_info->serv_software));
 543         hprintf("Connection: close\r\n");
 544         hprintf("Pragma: no-cache\r\nCache-Control: no-store\r\nExpires:-1\r\n");
 545         begin_burst();
 546         DoTemplate(HKEY("json_roomflr"),NULL,&NoCtx);
 547         end_burst();
 548 }
 549
 550
 551
 552 void
 553 InitModule_ROOMLIST
 554 (void)
 555 {
 556         WebcitAddUrlHandler(HKEY("json_roomflr"), jsonRoomFlr, 0);
 557
 558
 559         RegisterNamespace("FLOOR:ID", 0, 0, tmplput_FLOOR_ID, CTX_FLOORS);
 560         RegisterNamespace("FLOOR:NAME", 0, 1, tmplput_FLOOR_NAME, CTX_FLOORS);
 561         RegisterNamespace("FLOOR:NROOMS", 0, 0, tmplput_FLOOR_NROOMS, CTX_FLOORS);
 562
 563
 564
 565         RegisterIterator("LKRA", 0, NULL, GetRoomListHashLKRA, NULL, DeleteHash, CTX_ROOMS, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 566
 567         RegisterNamespace("ROOM:INFO:FLOORID", 0, 1, tmplput_ROOM_FLOORID, CTX_ROOMS);
 568         RegisterNamespace("ROOM:INFO:NAME", 0, 1, tmplput_ROOM_NAME, CTX_ROOMS);
 569         RegisterNamespace("ROOM:INFO:BASENAME", 0, 1, tmplput_ROOM_BASENAME, CTX_ROOMS);
 570         RegisterNamespace("ROOM:INFO:LEVELNTIMES", 1, 2, tmplput_ROOM_LEVEL_N_TIMES, CTX_ROOMS);
 571
 572         RegisterNamespace("ROOM:INFO:ACL", 0, 1, tmplput_ROOM_ACL, CTX_ROOMS);
 573         RegisterNamespace("ROOM:INFO:QRFLAGS", 0, 1, tmplput_ROOM_QRFLAGS, CTX_ROOMS);
 574         RegisterNamespace("ROOM:INFO:LISTORDER", 0, 1, tmplput_ROOM_LISTORDER, CTX_ROOMS);
 575         RegisterNamespace("ROOM:INFO:VIEW", 0, 1, tmplput_ROOM_VIEW, CTX_ROOMS);
 576         RegisterNamespace("ROOM:INFO:DEFVIEW", 0, 1, tmplput_ROOM_DEFVIEW, CTX_ROOMS);
 577         RegisterNamespace("ROOM:INFO:LASTCHANGE", 0, 1, tmplput_ROOM_LASTCHANGE, CTX_ROOMS);
 578         RegisterNamespace("ROOM:INFO:FLOOR:ID", 0, 0, tmplput_ROOM_FLOOR_ID, CTX_ROOMS);
 579         RegisterNamespace("ROOM:INFO:FLOOR:NAME", 0, 1, tmplput_ROOM_FLOOR_NAME, CTX_ROOMS);
 580         RegisterNamespace("ROOM:INFO:FLOOR:NROOMS", 0, 0, tmplput_ROOM_FLOOR_NROOMS, CTX_ROOMS);
 581
 582         RegisterSortFunc(HKEY("byfloorroom"),
 583                          NULL, 0,
 584                          CompareRoomListByFloorRoomPrivFirst,
 585                          CompareRoomListByFloorRoomPrivFirstRev,
 586                          GroupchangeRoomListByFloorRoomPrivFirst,
 587                          CTX_ROOMS);
 588
 589 }