webcit/roomlist.c

   1 /*
   2  * $Id$
   3  * room listings and filters.
   4  */
   5
   6 #include "webcit.h"
   7 #include "webserver.h"
   8
   9
  10 void DeleteFloor(void *vFloor)
  11 {
  12         Floor *pFloor;
  13         pFloor = (Floor*) vFloor;
  14         FreeStrBuf(&pFloor->Name);
  15         free(pFloor);
  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 {
  34         int Done = 0;
  35         const char *Err;
  36         StrBuf *Buf;
  37         HashList *floors;
  38         HashList *floorsbyname;
  39         HashPos *it;
  40         Floor *pFloor;
  41         void *vFloor;
  42         const char *Pos;
  43         int i;
  44         wcsession *WCC = WC;
  45         const char *HashKey;
  46         long HKLen;
  47
  48
  49         if (WCC->Floors != NULL)
  50                 return WCC->Floors;
  51         WCC->Floors = floors = NewHash(1, Flathash);
  52         WCC->FloorsByName = floorsbyname = NewHash(1, NULL);
  53         Buf = NewStrBuf();
  54
  55         pFloor = (Floor*) malloc(sizeof(Floor));
  56         pFloor->ID = VIRTUAL_MY_FLOOR;
  57         pFloor->Name = NewStrBufPlain(_("My Folders"), -1);
  58         pFloor->NRooms = 0;
  59
  60         Put(floors, IKEY(pFloor->ID), pFloor, DeleteFloor);
  61         Put(floorsbyname, SKEY(pFloor->Name), pFloor, reference_free_handler);
  62
  63         serv_puts("LFLR"); /* get floors */
  64         StrBufTCP_read_line(Buf, &WC->serv_sock, 0, &Err); /* '100', we hope */
  65         if (GetServerStatus(Buf, NULL) == 1)
  66         {
  67                 while(!Done && StrBuf_ServGetln(Buf))
  68                         if ( (StrLength(Buf)==3) &&
  69                              !strcmp(ChrPtr(Buf), "000"))
  70                         {
  71                                 Done = 1;
  72                         }
  73                         else
  74                         {
  75
  76                                 Pos = NULL;
  77
  78                                 pFloor = (Floor*) malloc(sizeof(Floor));
  79                                 pFloor->ID = StrBufExtractNext_int(Buf, &Pos, '|');
  80                                 pFloor->Name = NewStrBufPlain(NULL, StrLength(Buf));
  81                                 StrBufExtract_NextToken(pFloor->Name, Buf, &Pos, '|');
  82                                 pFloor->NRooms = StrBufExtractNext_long(Buf, &Pos, '|');
  83
  84                                 Put(floors, IKEY(pFloor->ID), pFloor, DeleteFloor);
  85                                 Put(floorsbyname, SKEY(pFloor->Name), pFloor, reference_free_handler);
  86                         }
  87         }
  88         FreeStrBuf(&Buf);
  89
  90         /* now lets pre-sort them alphabeticaly. */
  91         i = 1;
  92         SortByPayload(floors, SortFloorsByNameOrder);
  93         it = GetNewHashPos(floors, 0);
  94         while ( GetNextHashPos(floors, it, &HKLen, &HashKey, &vFloor))
  95                 ((Floor*) vFloor)->AlphaN = i++;
  96         DeleteHashPos(&it);
  97         SortByHashKeyStr(floors);
  98
  99         return floors;
 100 }
 101
 102 void tmplput_FLOOR_ID(StrBuf *Target, WCTemplputParams *TP)
 103 {
 104         Floor *myFloor = (Floor *)CTX;
 105
 106         StrBufAppendPrintf(Target, "%d", myFloor->ID);
 107 }
 108
 109 void tmplput_FLOOR_NAME(StrBuf *Target, WCTemplputParams *TP)
 110 {
 111         Floor *myFloor = (Floor *)CTX;
 112
 113         StrBufAppendTemplate(Target, TP, myFloor->Name, 0);
 114 }
 115
 116 void tmplput_FLOOR_NROOMS(StrBuf *Target, WCTemplputParams *TP)
 117 {
 118         Floor *myFloor = (Floor *)CTX;
 119
 120         StrBufAppendPrintf(Target, "%d", myFloor->NRooms);
 121 }
 122 HashList *GetRoomListHashLKRA(StrBuf *Target, WCTemplputParams *TP)
 123 {
 124         wcsession *WCC = WC;
 125
 126         if (WCC->Floors == NULL)
 127                 GetFloorListHash(Target, TP);
 128
 129         if (WCC->Rooms == NULL)
 130         {
 131                 serv_puts("LKRA");
 132                 WCC->Rooms =  GetRoomListHash(Target, TP);
 133         }
 134         return WCC->Rooms;
 135 }
 136
 137 void FlushFolder(folder *room)
 138 {
 139         int i;
 140
 141         FreeStrBuf(&room->name);
 142         if (room->IgnetCfgs[0] == (HashList*) StrBufNOTNULL)
 143         {
 144                 room->IgnetCfgs[0] = NULL;
 145                 for (i = ignet_push_share; i < maxRoomNetCfg; i++)
 146                         DeleteHash(&room->IgnetCfgs[i]);
 147         }
 148         if (room->RoomNameParts != NULL)
 149         {
 150                 for (i=0; i < room->nRoomNameParts; i++)
 151                         FreeStrBuf(&room->RoomNameParts[i]);
 152                 free(room->RoomNameParts);
 153         }
 154 }
 155
 156 void vDeleteFolder(void *vFolder)
 157 {
 158         folder *room;
 159
 160         room = (folder*) vFolder;
 161         FlushFolder(room);
 162
 163         free(room);
 164 }
 165
 166
 167 HashList *GetRoomListHash(StrBuf *Target, WCTemplputParams *TP)
 168 {
 169         int Done = 0;
 170         HashList *rooms;
 171         folder *room;
 172         StrBuf *Buf;
 173         const char *Pos;
 174         void *vFloor;
 175         wcsession *WCC = WC;
 176         CompareFunc SortIt;
 177         WCTemplputParams SubTP;
 178
 179         Buf = NewStrBuf();
 180         rooms = NewHash(1, NULL);
 181         StrBuf_ServGetln(Buf);
 182         if (GetServerStatus(Buf, NULL) == 1)
 183         {
 184                 while(!Done && StrBuf_ServGetln(Buf))
 185                         if ( (StrLength(Buf)==3) &&
 186                              !strcmp(ChrPtr(Buf), "000"))
 187                         {
 188                                 Done = 1;
 189                         }
 190                         else
 191                         {
 192                                 Pos = NULL;
 193                                 room = (folder*) malloc (sizeof(folder));
 194                                 memset(room, 0, sizeof(folder));
 195
 196                                 /* Load the base data from the server reply */
 197                                 room->name = NewStrBufPlain(NULL, StrLength(Buf));
 198                                 StrBufExtract_NextToken(room->name, Buf, &Pos, '|');
 199
 200                                 room->QRFlags = StrBufExtractNext_long(Buf, &Pos, '|');
 201                                 room->floorid = StrBufExtractNext_int(Buf, &Pos, '|');
 202                                 room->listorder = StrBufExtractNext_long(Buf, &Pos, '|');
 203                                 room->QRFlags2 = StrBufExtractNext_long(Buf, &Pos, '|');
 204
 205                                 room->RAFlags = StrBufExtractNext_long(Buf, &Pos, '|');
 206
 207 /*
 208   ACWHUT?
 209   room->ACL = NewStrBufPlain(NULL, StrLength(Buf));
 210   StrBufExtract_NextToken(room->ACL, Buf, &Pos, '|');
 211 */
 212
 213                                 room->view = StrBufExtractNext_long(Buf, &Pos, '|');
 214                                 room->defview = StrBufExtractNext_long(Buf, &Pos, '|');
 215                                 room->lastchange = StrBufExtractNext_long(Buf, &Pos, '|');
 216
 217                                 /* Evaluate the Server sent data for later use */
 218                                 /* find out, whether we are in a sub-room */
 219                                 room->nRoomNameParts = StrBufNum_tokens(room->name, '\\');
 220                                 if (room->nRoomNameParts > 1)
 221                                 {
 222                                         int i;
 223
 224                                         Pos = NULL;
 225                                         room->RoomNameParts = malloc(sizeof(StrBuf*) * (room->nRoomNameParts + 1));
 226                                         memset(room->RoomNameParts, 0, sizeof(StrBuf*) * (room->nRoomNameParts + 1));
 227                                         for (i=0; i < room->nRoomNameParts; i++)
 228                                         {
 229                                                 room->RoomNameParts[i] = NewStrBuf();
 230                                                 StrBufExtract_NextToken(room->RoomNameParts[i],
 231                                                                         room->name, &Pos, '\\');
 232                                         }
 233                                 }
 234
 235                                 /* Private mailboxes on the main floor get remapped to the personal folder */
 236                                 if ((room->QRFlags & QR_MAILBOX) &&
 237                                     (room->floorid == 0))
 238                                 {
 239                                         room->floorid = VIRTUAL_MY_FLOOR;
 240                                         if ((room->nRoomNameParts == 1) &&
 241                                             (StrLength(room->name) == 4) &&
 242                                             (strcmp(ChrPtr(room->name), "Mail") == 0))
 243                                         {
 244                                                 room->is_inbox = 1;
 245                                         }
 246
 247                                 }
 248                                 /* get a pointer to the floor we're on: */
 249                                 GetHash(WCC->Floors, IKEY(room->floorid), &vFloor);
 250                                 room->Floor = (const Floor*) vFloor;
 251
 252
 253
 254                                 /* now we know everything, remember it... */
 255                                 Put(rooms, SKEY(room->name), room, vDeleteFolder);
 256                         }
 257         }
 258
 259         SubTP.Filter.ContextType = CTX_ROOMS;
 260         SortIt = RetrieveSort(&SubTP, NULL, 0, HKEY("fileunsorted"), 0);
 261         if (SortIt != NULL)
 262                 SortByPayload(rooms, SortIt);
 263         else
 264                 SortByPayload(rooms, SortRoomsByListOrder);
 265         FreeStrBuf(&Buf);
 266         return rooms;
 267 }
 268
 269 HashList *GetNetConfigHash(StrBuf *Target, WCTemplputParams *TP)
 270 {
 271         wcsession *WCC = WC;
 272         StrBuf *Line;
 273         StrBuf *Token;
 274         StrBuf *Content;
 275         long WantThisOne;
 276         long PutTo;
 277         long State;
 278
 279         WantThisOne = GetTemplateTokenNumber(Target, TP, 5, 0);
 280         if (WantThisOne == 0)
 281                 return NULL;
 282         if (WCC->CurRoom.IgnetCfgs[0] == (HashList*) StrBufNOTNULL)
 283                 return WCC->CurRoom.IgnetCfgs[WantThisOne];
 284
 285         WCC->CurRoom.IgnetCfgs[0] = (HashList*) StrBufNOTNULL;
 286         serv_puts("GNET");
 287         Line = NewStrBuf();
 288         Token = NewStrBuf();
 289         StrBuf_ServGetln(Line);
 290         if (GetServerStatus(Line, &State) == 1)
 291         {
 292                 const char *Pos = NULL;
 293                 StrBuf_ServGetln(Line);
 294                 StrBufExtract_NextToken(Token, Line, &Pos, '|');
 295                 PutTo = GetTokenDefine(SKEY(Token), -1);
 296                 if ((PutTo > 0) &&
 297                     (PutTo < maxRoomNetCfg) &&
 298                     (Pos != StrBufNOTNULL))
 299                 {
 300                         int n;
 301                         HashList *SubH;
 302
 303                         if (WCC->CurRoom.IgnetCfgs[PutTo] == NULL)
 304                                 WCC->CurRoom.IgnetCfgs[PutTo] = NewHash(1, NULL);
 305                         SubH = NewHash(1, NULL);
 306                         n = GetCount(WCC->CurRoom.IgnetCfgs[PutTo]) + 1;
 307                         Put(WCC->CurRoom.IgnetCfgs[PutTo],
 308                             IKEY(n),
 309                             SubH,
 310                             HDeleteHash);
 311                         while (Pos != StrBufNOTNULL) {
 312                                 Content = NewStrBuf();
 313                                 StrBufExtract_NextToken(Content, Line, &Pos, '|');
 314                                 Put(SubH,
 315                                     IKEY(n),
 316                                     Content,
 317                                     HFreeStrBuf);
 318                         }
 319                 }
 320         }
 321         else if (State == 550)
 322                 StrBufAppendBufPlain(WCC->ImportantMsg,
 323                                      _("Higher access is required to access this function."), -1, 0);
 324
 325
 326         return WCC->CurRoom.IgnetCfgs[WantThisOne];
 327 }
 328
 329 /** Unused function that orders rooms by the listorder flag */
 330 int SortRoomsByListOrder(const void *room1, const void *room2)
 331 {
 332         folder *r1 = (folder*) GetSearchPayload(room1);
 333         folder *r2 = (folder*) GetSearchPayload(room2);
 334
 335         if (r1->listorder == r2->listorder) return 0;
 336         if (r1->listorder > r2->listorder) return 1;
 337         return -1;
 338 }
 339
 340 int CompareRoomListByFloorRoomPrivFirst(const void *room1, const void *room2)
 341 {
 342         folder *r1 = (folder*) GetSearchPayload(room1);
 343         folder *r2 = (folder*) GetSearchPayload(room2);
 344
 345         if ((r1->Floor == NULL)  ||
 346             (r2->Floor == NULL))
 347                 return 0;
 348
 349         /**
 350          * are we on the same floor? else sort by floor.
 351          */
 352         if (r1->Floor != r2->Floor)
 353         {
 354                 /**
 355                  * the private rooms are first in any case.
 356                  */
 357                 if (r1->Floor->ID == VIRTUAL_MY_FLOOR)
 358                         return -1;
 359                 if (r2->Floor->ID == VIRTUAL_MY_FLOOR)
 360                         return 1;
 361                 /**
 362                  * else decide alpaheticaly by floorname
 363                  */
 364                 return (r1->Floor->AlphaN > r2->Floor->AlphaN)? 1 : -1;
 365         }
 366
 367         /**
 368          * if we have different levels of subdirectories,
 369          * we want the toplevel to be first, regardless of sort
 370          * sequence.
 371          */
 372         if (((r1->nRoomNameParts > 1) ||
 373             (r2->nRoomNameParts > 1)    )&&
 374             (r1->nRoomNameParts != r2->nRoomNameParts))
 375         {
 376                 int i, ret;
 377                 int nparts = (r1->nRoomNameParts > r2->nRoomNameParts)?
 378                         r2->nRoomNameParts : r1->nRoomNameParts;
 379
 380                 for (i=0; i < nparts; i++)
 381                 {
 382                         ret = strcmp (ChrPtr(r1->name),
 383                                       ChrPtr(r2->name));
 384                         /**
 385                          * Deltas in common parts? exit here.
 386                          */
 387                         if (ret != 0)
 388                                 return ret;
 389                 }
 390
 391                 /**
 392                  * who's a subdirectory of whom?
 393                  */
 394                 if (r1->nRoomNameParts > r2->nRoomNameParts)
 395                         return 1;
 396                 else
 397                         return -1;
 398
 399         }
 400
 401         /**
 402          * else just sort alphabeticaly.
 403          */
 404         return strcmp (ChrPtr(r1->name),
 405                        ChrPtr(r2->name));
 406 }
 407
 408 int CompareRoomListByFloorRoomPrivFirstRev(const void *room1, const void *room2)
 409 {
 410         folder *r1 = (folder*) GetSearchPayload(room1);
 411         folder *r2 = (folder*) GetSearchPayload(room2);
 412
 413         if ((r1->Floor == NULL)  ||
 414             (r2->Floor == NULL))
 415                 return 0;
 416
 417         /**
 418          * are we on the same floor? else sort by floor.
 419          */
 420         if (r2->Floor != r1->Floor)
 421         {
 422                 /**
 423                  * the private rooms are first in any case.
 424                  */
 425                 if (r1->Floor->ID == VIRTUAL_MY_FLOOR)
 426                         return -1;
 427                 if (r2->Floor->ID == VIRTUAL_MY_FLOOR)
 428                         return 1;
 429                 /**
 430                  * else decide alpaheticaly by floorname
 431                  */
 432
 433                 return (r1->Floor->AlphaN < r2->Floor->AlphaN)? 1 : -1;
 434         }
 435
 436         /**
 437          * if we have different levels of subdirectories,
 438          * we want the toplevel to be first, regardless of sort
 439          * sequence.
 440          */
 441         if (((r1->nRoomNameParts > 1) ||
 442             (r2->nRoomNameParts > 1)    )&&
 443             (r1->nRoomNameParts != r2->nRoomNameParts))
 444         {
 445                 int i, ret;
 446                 int nparts = (r1->nRoomNameParts > r2->nRoomNameParts)?
 447                         r2->nRoomNameParts : r1->nRoomNameParts;
 448
 449                 for (i=0; i < nparts; i++)
 450                 {
 451                         /**
 452                          * special cases if one room is top-level...
 453                          */
 454                         if (r2->nRoomNameParts == 1)
 455                                 ret = strcmp (ChrPtr(r2->name),
 456                                               ChrPtr(r1->RoomNameParts[i]));
 457                         else if (r1->nRoomNameParts == 1)
 458                                 ret = strcmp (ChrPtr(r2->RoomNameParts[i]),
 459                                               ChrPtr(r1->name));
 460                         else
 461                                 ret = strcmp (ChrPtr(r2->RoomNameParts[i]),
 462                                               ChrPtr(r1->RoomNameParts[i]));
 463                         /**
 464                          * Deltas in common parts? exit here.
 465                          */
 466                         if (ret != 0)
 467                                 return ret;
 468                 }
 469
 470                 /**
 471                  * who's a subdirectory of whom?
 472                  */
 473                 if (r1->nRoomNameParts > r2->nRoomNameParts)
 474                         return 1;
 475                 else
 476                         return -1;
 477         }
 478
 479         return strcmp (ChrPtr(r2->name),
 480                        ChrPtr(r1->name));
 481 }
 482
 483 int GroupchangeRoomListByFloorRoomPrivFirst(const void *room1, const void *room2)
 484 {
 485         folder *r1 = (folder*) room1;
 486         folder *r2 = (folder*) room2;
 487
 488
 489         if ((r1->Floor == NULL)  ||
 490             (r2->Floor == NULL))
 491                 return 0;
 492
 493         if (r1->Floor == r2->Floor)
 494                 return 0;
 495         else
 496         {
 497                 wcsession *WCC = WC;
 498                 static int columns = 3;
 499                 int boxes_per_column = 0;
 500                 int nf;
 501
 502                 nf = GetCount(WCC->Floors);
 503                 while (nf % columns != 0) ++nf;
 504                 boxes_per_column = (nf / columns);
 505                 if (boxes_per_column < 1)
 506                         boxes_per_column = 1;
 507                 if (r1->Floor->AlphaN % boxes_per_column == 0)
 508                         return 2;
 509                 else
 510                         return 1;
 511         }
 512 }
 513
 514
 515 int CompareRooms(const folder *room1, const folder *room2)
 516 {
 517         if ((room1 == NULL) || (room2 == NULL))
 518                 return -1;
 519         return CompareRoomListByFloorRoomPrivFirst(room1, room2);
 520 }
 521
 522
 523
 524 void tmplput_ROOM_NAME(StrBuf *Target, WCTemplputParams *TP)
 525 {
 526         folder *Folder = (folder *)CTX;
 527
 528         StrBufAppendTemplate(Target, TP, Folder->name, 0);
 529 }
 530 void tmplput_ROOM_BASENAME(StrBuf *Target, WCTemplputParams *TP)
 531 {
 532         folder *room = (folder *)CTX;
 533
 534         if (room->nRoomNameParts > 1)
 535                 StrBufAppendTemplate(Target, TP,
 536                                       room->RoomNameParts[room->nRoomNameParts - 1], 0);
 537         else
 538                 StrBufAppendTemplate(Target, TP, room->name, 0);
 539 }
 540 void tmplput_ROOM_LEVEL_N_TIMES(StrBuf *Target, WCTemplputParams *TP)
 541 {
 542         folder *room = (folder *)CTX;
 543         int i;
 544         const char *AppendMe;
 545         long AppendMeLen;
 546
 547
 548         if (room->nRoomNameParts > 1)
 549         {
 550                 GetTemplateTokenString(Target, TP, 0, &AppendMe, &AppendMeLen);
 551                 for (i = 0; i < room->nRoomNameParts; i++)
 552                         StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0);
 553         }
 554 }
 555
 556 void tmplput_ROOM_ACL(StrBuf *Target, WCTemplputParams *TP)
 557 {
 558         folder *Folder = (folder *)CTX;
 559
 560         StrBufAppendPrintf(Target, "%ld", Folder->RAFlags, 0);
 561 }
 562
 563
 564 void tmplput_ROOM_QRFLAGS(StrBuf *Target, WCTemplputParams *TP)
 565 {
 566         folder *Folder = (folder *)CTX;
 567         StrBufAppendPrintf(Target, "%d", Folder->QRFlags);
 568 }
 569
 570 void tmplput_ROOM_RAFLAGS(StrBuf *Target, WCTemplputParams *TP)
 571 {
 572         folder *Folder = (folder *)(TP->Context);
 573         StrBufAppendPrintf(Target, "%d", Folder->RAFlags);
 574 }
 575
 576
 577 void tmplput_ROOM_FLOORID(StrBuf *Target, WCTemplputParams *TP)
 578 {
 579         folder *Folder = (folder *)CTX;
 580         StrBufAppendPrintf(Target, "%d", Folder->floorid);
 581 }
 582
 583 void tmplput_ROOM_LISTORDER(StrBuf *Target, WCTemplputParams *TP)
 584 {
 585         folder *Folder = (folder *)CTX;
 586         StrBufAppendPrintf(Target, "%d", Folder->listorder);
 587 }
 588 void tmplput_ROOM_VIEW(StrBuf *Target, WCTemplputParams *TP)
 589 {
 590         folder *Folder = (folder *)CTX;
 591         StrBufAppendPrintf(Target, "%d", Folder->view);
 592 }
 593 void tmplput_ROOM_DEFVIEW(StrBuf *Target, WCTemplputParams *TP)
 594 {
 595         folder *Folder = (folder *)CTX;
 596         StrBufAppendPrintf(Target, "%d", Folder->defview);
 597 }
 598 void tmplput_ROOM_LASTCHANGE(StrBuf *Target, WCTemplputParams *TP)
 599 {
 600         folder *Folder = (folder *)CTX;
 601         StrBufAppendPrintf(Target, "%d", Folder->lastchange);
 602 }
 603 void tmplput_ROOM_FLOOR_ID(StrBuf *Target, WCTemplputParams *TP)
 604 {
 605         folder *Folder = (folder *)CTX;
 606         const Floor *pFloor = Folder->Floor;
 607
 608         if (pFloor == NULL)
 609                 return;
 610
 611         StrBufAppendPrintf(Target, "%d", pFloor->ID);
 612 }
 613
 614 void tmplput_ROOM_FLOOR_NAME(StrBuf *Target, WCTemplputParams *TP)
 615 {
 616         folder *Folder = (folder *)CTX;
 617         const Floor *pFloor = Folder->Floor;
 618
 619         if (pFloor == NULL)
 620                 return;
 621
 622         StrBufAppendTemplate(Target, TP, pFloor->Name, 0);
 623 }
 624
 625 void tmplput_ROOM_FLOOR_NROOMS(StrBuf *Target, WCTemplputParams *TP)
 626 {
 627         folder *Folder = (folder *)CTX;
 628         const Floor *pFloor = Folder->Floor;
 629
 630         if (pFloor == NULL)
 631                 return;
 632         StrBufAppendPrintf(Target, "%d", pFloor->NRooms);
 633 }
 634
 635
 636
 637 int ConditionalRoomHas_UA_KNOWN(StrBuf *Target, WCTemplputParams *TP)
 638 {
 639         folder *Folder = (folder *)CTX;
 640         return (Folder->RAFlags & UA_KNOWN) != 0;
 641 }
 642
 643 int ConditionalRoomHas_UA_GOTOALLOWED(StrBuf *Target, WCTemplputParams *TP)
 644 {
 645         folder *Folder = (folder *)CTX;
 646         return (Folder->RAFlags & UA_GOTOALLOWED) != 0;
 647 }
 648
 649 int ConditionalRoomHas_UA_HASNEWMSGS(StrBuf *Target, WCTemplputParams *TP)
 650 {
 651         folder *Folder = (folder *)CTX;
 652         return (Folder->RAFlags & UA_HASNEWMSGS) != 0;
 653 }
 654
 655 int ConditionalRoomHas_UA_ZAPPED(StrBuf *Target, WCTemplputParams *TP)
 656 {
 657         folder *Folder = (folder *)CTX;
 658         return (Folder->RAFlags & UA_ZAPPED) != 0;
 659 }
 660
 661 int ConditionalRoomHas_UA_POSTALLOWED(StrBuf *Target, WCTemplputParams *TP)
 662 {
 663         folder *Folder = (folder *)CTX;
 664         return (Folder->RAFlags & UA_POSTALLOWED) != 0;
 665 }
 666
 667 int ConditionalRoomHas_UA_ADMINALLOWED(StrBuf *Target, WCTemplputParams *TP)
 668 {
 669         folder *Folder = (folder *)CTX;
 670         return (Folder->RAFlags & UA_ADMINALLOWED) != 0;
 671 }
 672
 673 int ConditionalRoomHas_UA_DELETEALLOWED(StrBuf *Target, WCTemplputParams *TP)
 674 {
 675         folder *Folder = (folder *)CTX;
 676         return (Folder->RAFlags & UA_DELETEALLOWED) != 0;
 677 }
 678
 679
 680 int ConditionalRoomIsInbox(StrBuf *Target, WCTemplputParams *TP)
 681 {
 682         folder *Folder = (folder *)CTX;
 683         return Folder->is_inbox;
 684 }
 685
 686 void tmplput_ROOM_COLLECTIONTYPE(StrBuf *Target, WCTemplputParams *TP)
 687 {
 688         folder *Folder = (folder *)CTX;
 689
 690         switch(Folder->view) {
 691         case VIEW_CALENDAR:
 692                 StrBufAppendBufPlain(Target, HKEY("vevent"), 0);
 693                 break;
 694         case VIEW_TASKS:
 695                 StrBufAppendBufPlain(Target, HKEY("vtodo"), 0);
 696                 break;
 697         case VIEW_ADDRESSBOOK:
 698                 StrBufAppendBufPlain(Target, HKEY("vcard"), 0);
 699                 break;
 700         case VIEW_NOTES:
 701                 StrBufAppendBufPlain(Target, HKEY("vnotes"), 0);
 702                 break;
 703         case VIEW_JOURNAL:
 704                 StrBufAppendBufPlain(Target, HKEY("vjournal"), 0);
 705                 break;
 706         case VIEW_WIKI:
 707                 StrBufAppendBufPlain(Target, HKEY("wiki"), 0);
 708                 break;
 709         }
 710 }
 711
 712
 713
 714
 715 int ConditionalRoomHasGroupdavContent(StrBuf *Target, WCTemplputParams *TP)
 716 {
 717         folder *Folder = (folder *)CTX;
 718
 719         lprintf(0, "-> %s: %ld\n", ChrPtr(Folder->name), Folder->view);
 720
 721         return ((Folder->view == VIEW_CALENDAR) ||
 722                 (Folder->view == VIEW_TASKS) ||
 723                 (Folder->view == VIEW_ADDRESSBOOK) ||
 724                 (Folder->view == VIEW_NOTES) ||
 725                 (Folder->view == VIEW_JOURNAL) );
 726 }
 727
 728
 729
 730 int ConditionalFloorIsRESTSubFloor(StrBuf *Target, WCTemplputParams *TP)
 731 {
 732         wcsession  *WCC = WC;
 733         Floor *MyFloor = (Floor *)CTX;
 734         /** if we have dav_depth the client just wants the subfloors */
 735         if ((WCC->Hdr->HR.dav_depth == 1) &&
 736             (GetCount(WCC->Directory) == 0))
 737                 return 1;
 738         return WCC->CurrentFloor == MyFloor;
 739 }
 740
 741
 742 int ConditionalFloorIsSUBROOM(StrBuf *Target, WCTemplputParams *TP)
 743 {
 744         wcsession  *WCC = WC;
 745         Floor *MyFloor = (Floor *)CTX;
 746
 747         return WCC->CurRoom.floorid == MyFloor->ID;
 748 }
 749
 750
 751 int ConditionalRoomIsRESTSubRoom(StrBuf *Target, WCTemplputParams *TP)
 752 {
 753         wcsession  *WCC = WC;
 754         folder     *Folder = (folder *)CTX;
 755         HashPos    *it;
 756         StrBuf     * Dir;
 757         void       *vDir;
 758         long        len;
 759         const char *Key;
 760         int i, j, urlp;
 761         int delta;
 762
 763
 764         /* list only folders relative to the current floor... */
 765         if (Folder->Floor != WCC->CurrentFloor)
 766                 return 0;
 767
 768         urlp = GetCount(WCC->Directory);
 769         delta = Folder->nRoomNameParts - urlp + 1;
 770
 771         lprintf(0, "\n->%s: %ld - %ld ", ChrPtr(Folder->name), urlp,
 772                 Folder->nRoomNameParts);
 773         /* list only the floors which are in relation to the dav_depth header */
 774         if (WCC->Hdr->HR.dav_depth != delta) {
 775                 lprintf(0, "1\n");
 776                 return 0;
 777         }
 778
 779
 780         it = GetNewHashPos(WCC->Directory, 0);
 781         /* Fast forward the floorname we checked above... */
 782         GetNextHashPos(WCC->Directory, it, &len, &Key, &vDir);
 783
 784         if (Folder->nRoomNameParts > 1) {
 785                 for (i = 0, j = 1;
 786                      (i > Folder->nRoomNameParts) && (j > urlp);
 787                      i++, j++)
 788                 {
 789                         if (!GetNextHashPos(WCC->Directory,
 790                                             it, &len, &Key, &vDir) ||
 791                             (vDir == NULL))
 792                         {
 793                                 DeleteHashPos(&it);
 794
 795                                 lprintf(0, "3\n");
 796                                 return 0;
 797                         }
 798                         Dir = (StrBuf*) vDir;
 799                         if (strcmp(ChrPtr(Folder->RoomNameParts[i]),
 800                                    ChrPtr(Dir)) != 0)
 801                         {
 802                                 DeleteHashPos(&it);
 803                                 lprintf(0, "4\n");
 804                                 return 0;
 805                         }
 806                 }
 807                 DeleteHashPos(&it);
 808                 return 1;
 809         }
 810         else {
 811                 if (!GetNextHashPos(WCC->Directory,
 812                                     it, &len, &Key, &vDir) ||
 813                     (vDir == NULL))
 814                 {
 815                         DeleteHashPos(&it);
 816
 817                         lprintf(0, "5\n");
 818                         return WCC->Hdr->HR.dav_depth == 1;
 819                 }
 820                 DeleteHashPos(&it);
 821                 Dir = (StrBuf*) vDir;
 822                 if (WCC->Hdr->HR.dav_depth == 0) {
 823                         return (strcmp(ChrPtr(Folder->name),
 824                                        ChrPtr(Dir))
 825                                 == 0);
 826
 827                 }
 828                 return 0;
 829         }
 830 }
 831
 832
 833 void jsonRoomFlr(void)
 834 {
 835         /* Send as our own (application/json) content type */
 836         hprintf("HTTP/1.1 200 OK\r\n");
 837         hprintf("Content-type: application/json; charset=utf-8\r\n");
 838         hprintf("Server: %s / %s\r\n", PACKAGE_STRING, ChrPtr(WC->serv_info->serv_software));
 839         hprintf("Connection: close\r\n");
 840         hprintf("Pragma: no-cache\r\nCache-Control: no-store\r\nExpires:-1\r\n");
 841         begin_burst();
 842         DoTemplate(HKEY("json_roomflr"),NULL,&NoCtx);
 843         end_burst();
 844 }
 845
 846
 847 void
 848 SessionDetachModule_ROOMLIST
 849 (wcsession *sess)
 850 {
 851         DeleteHash(&sess->Floors);
 852         DeleteHash(&sess->Rooms);
 853         DeleteHash(&sess->FloorsByName);
 854 }
 855
 856
 857 #define POP3_HOST 0
 858 #define POP3_USERNAME 1
 859 #define POP3_PASSWORD 2
 860 #define POP3_KEEP 3
 861 #define POP3_INTERVAL 4
 862
 863 void
 864 InitModule_ROOMLIST
 865 (void)
 866 {
 867
 868         REGISTERTokenParamDefine(POP3_HOST);
 869         REGISTERTokenParamDefine(POP3_USERNAME);
 870         REGISTERTokenParamDefine(POP3_PASSWORD);
 871         REGISTERTokenParamDefine(POP3_KEEP);
 872         REGISTERTokenParamDefine(POP3_INTERVAL);
 873
 874
 875         WebcitAddUrlHandler(HKEY("json_roomflr"), "", 0, jsonRoomFlr, 0);
 876
 877
 878         RegisterNamespace("FLOOR:ID", 0, 0, tmplput_FLOOR_ID, NULL, CTX_FLOORS);
 879         RegisterNamespace("FLOOR:NAME", 0, 1, tmplput_FLOOR_NAME, NULL, CTX_FLOORS);
 880         RegisterNamespace("FLOOR:NROOMS", 0, 0, tmplput_FLOOR_NROOMS, NULL, CTX_FLOORS);
 881         RegisterConditional(HKEY("COND:FLOOR:ISSUBROOM"), 0, ConditionalFloorIsSUBROOM, CTX_FLOORS);
 882         RegisterConditional(HKEY("COND:ROOM:REST:ISSUBFLOOR"), 0, ConditionalFloorIsRESTSubFloor, CTX_FLOORS);
 883
 884         RegisterIterator("ITERATE:THISROOM:GNET", 1, NULL, GetNetConfigHash, NULL, NULL, CTX_STRBUFARR, CTX_NONE, IT_NOFLAG);
 885
 886         RegisterIterator("LFLR", 0, NULL, GetFloorListHash, NULL, NULL, CTX_FLOORS, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 887
 888         RegisterIterator("LKRA", 0, NULL, GetRoomListHashLKRA, NULL, NULL, CTX_ROOMS, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 889
 890         RegisterNamespace("ROOM:INFO:FLOORID", 0, 1, tmplput_ROOM_FLOORID, NULL, CTX_ROOMS);
 891         RegisterNamespace("ROOM:INFO:NAME", 0, 1, tmplput_ROOM_NAME, NULL, CTX_ROOMS);
 892         RegisterNamespace("ROOM:INFO:PRINT_NAME", 0, 1, tmplput_ROOM_NAME, NULL, CTX_ROOMS);/// TODO!
 893         RegisterNamespace("ROOM:INFO:BASENAME", 0, 1, tmplput_ROOM_BASENAME, NULL, CTX_ROOMS);
 894         RegisterNamespace("ROOM:INFO:LEVELNTIMES", 1, 2, tmplput_ROOM_LEVEL_N_TIMES, NULL, CTX_ROOMS);
 895
 896         RegisterNamespace("ROOM:INFO:ACL", 0, 1, tmplput_ROOM_ACL, NULL, CTX_ROOMS);
 897         RegisterNamespace("ROOM:INFO:QRFLAGS", 0, 1, tmplput_ROOM_QRFLAGS, NULL, CTX_ROOMS);
 898         RegisterNamespace("ROOM:INFO:RAFLAGS", 0, 1, tmplput_ROOM_RAFLAGS, NULL, CTX_ROOMS);
 899         RegisterNamespace("ROOM:INFO:LISTORDER", 0, 1, tmplput_ROOM_LISTORDER, NULL, CTX_ROOMS);
 900         RegisterNamespace("ROOM:INFO:VIEW", 0, 1, tmplput_ROOM_VIEW, NULL, CTX_ROOMS);
 901         RegisterNamespace("ROOM:INFO:DEFVIEW", 0, 1, tmplput_ROOM_DEFVIEW, NULL, CTX_ROOMS);
 902         RegisterNamespace("ROOM:INFO:LASTCHANGE", 0, 1, tmplput_ROOM_LASTCHANGE, NULL, CTX_ROOMS);
 903         RegisterNamespace("ROOM:INFO:COLLECTIONTYPE", 0, 1, tmplput_ROOM_COLLECTIONTYPE, NULL, CTX_ROOMS);
 904         RegisterNamespace("ROOM:INFO:FLOOR:ID", 0, 0, tmplput_ROOM_FLOOR_ID, NULL, CTX_ROOMS);
 905         RegisterNamespace("ROOM:INFO:FLOOR:NAME", 0, 1, tmplput_ROOM_FLOOR_NAME, NULL, CTX_ROOMS);
 906         RegisterNamespace("ROOM:INFO:FLOOR:NROOMS", 0, 0, tmplput_ROOM_FLOOR_NROOMS, NULL, CTX_ROOMS);
 907
 908         RegisterConditional(HKEY("COND:ROOM:REST:ISSUBROOM"), 0, ConditionalRoomIsRESTSubRoom, CTX_ROOMS);
 909
 910         RegisterConditional(HKEY("COND:ROOM:INFO:IS_INBOX"), 0, ConditionalRoomIsInbox, CTX_ROOMS);
 911         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_KNOWN"), 0, ConditionalRoomHas_UA_KNOWN, CTX_ROOMS);
 912         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_GOTOALLOWED"), 0, ConditionalRoomHas_UA_GOTOALLOWED, CTX_ROOMS);
 913         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_HASNEWMSGS"), 0, ConditionalRoomHas_UA_HASNEWMSGS, CTX_ROOMS);
 914         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_ZAPPED"), 0, ConditionalRoomHas_UA_ZAPPED, CTX_ROOMS);
 915         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_POSTALLOWED"), 0, ConditionalRoomHas_UA_POSTALLOWED, CTX_ROOMS);
 916         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_ADMINALLOWED"), 0, ConditionalRoomHas_UA_ADMINALLOWED, CTX_ROOMS);
 917         RegisterConditional(HKEY("COND:ROOM:FLAGS:UA_DELETEALLOWED"), 0, ConditionalRoomHas_UA_DELETEALLOWED, CTX_ROOMS);
 918         RegisterConditional(HKEY("COND:ROOM:GROUPDAV_CONTENT"), 0, ConditionalRoomHasGroupdavContent, CTX_ROOMS);
 919
 920
 921
 922         RegisterSortFunc(HKEY("byfloorroom"),
 923                          NULL, 0,
 924                          CompareRoomListByFloorRoomPrivFirst,
 925                          CompareRoomListByFloorRoomPrivFirstRev,
 926                          GroupchangeRoomListByFloorRoomPrivFirst,
 927                          CTX_ROOMS);
 928
 929 }