source/objects/calendarfreebusy/CalendarFreeBusy.cpp

   1 // CalendarFreeBusy.cpp - CalendarFreeBusy class functions
   2 //
   3 // (c) 2016-2017 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Calendar.
   6 //
   7 // Xestia Calendar is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by the
   9 // Free Software Foundation, version 3 of the license.
  10 //
  11 // Xestia Calendar is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with Xestia Calendar. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include "CalendarFreeBusy.h"
  20
  21 using namespace std;
  22
  23 CalendarObjectValidResult CalendarFreeBusyObject::ValidObject(){
  24
  25         bool ValidBegin = false;
  26         bool ValidEnd = false;
  27         bool ValidDateTimeStamp = false;
  28         bool ValidUniqueID = false;
  29         bool ValidDateTimeStart = false;
  30         int SeekCount = 0;
  31         string PropertyName;
  32
  33         // Look for BEGIN:VFREEBUSY.
  34
  35         for (vector<string>::iterator iter = ObjectName.begin();
  36                 iter != ObjectName.end(); iter++){
  37
  38                 if (ObjectName[SeekCount] == "BEGIN" &&
  39                         ObjectData[SeekCount] == "VFREEBUSY"){
  40
  41                         if (ValidBegin == false){
  42                                 ValidBegin = true;
  43                         } else {
  44                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
  45                         }
  46
  47                 }
  48
  49                 if (ObjectName[SeekCount] == "END" &&
  50                         ObjectData[SeekCount] == "VFREEBUSY" &&
  51                         ValidBegin == false){
  52
  53                         return CALENDAROBJECTVALID_INVALIDFORMAT;
  54
  55                 }
  56
  57                 SeekCount++;
  58
  59         }
  60
  61         SeekCount = 0;
  62
  63         // Look for DTSTAMP.
  64
  65         for (vector<string>::iterator iter = ObjectName.begin();
  66                 iter != ObjectName.end(); iter++){
  67
  68                 try{
  69                         PropertyName = ObjectName[SeekCount].substr(0,7);
  70                 }
  71
  72                 catch(const out_of_range& oor){
  73                         continue;
  74                 }
  75
  76                 if (PropertyName == "DTSTAMP"){
  77
  78                         if (ValidDateTimeStamp == false){
  79                                 ValidDateTimeStamp = true;
  80                         } else {
  81                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
  82                         }
  83
  84                 }
  85
  86                 SeekCount++;
  87
  88         }
  89
  90         SeekCount = 0;
  91
  92         // Look for UID.
  93
  94         for (vector<string>::iterator iter = ObjectName.begin();
  95                 iter != ObjectName.end(); iter++){
  96
  97                 try{
  98                         PropertyName = ObjectName[SeekCount].substr(0,3);
  99                 }
 100
 101                 catch(const out_of_range& oor){
 102                         continue;
 103                 }
 104
 105                 if (PropertyName == "UID"){
 106
 107                         if (ValidUniqueID == false){
 108                                 ValidUniqueID = true;
 109                         } else {
 110                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 111                         }
 112
 113                 }
 114
 115                 SeekCount++;
 116
 117         }
 118
 119         SeekCount = 0;
 120
 121         // Look for END:VFREEBUSY.
 122
 123         for (vector<string>::iterator iter = ObjectName.begin();
 124                 iter != ObjectName.end(); iter++){
 125
 126                 if (ObjectName[SeekCount] == "END" &&
 127                         ObjectData[SeekCount] == "VFREEBUSY"){
 128
 129                         if (ValidEnd == false){
 130                                 ValidEnd = true;
 131                         } else {
 132                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 133                         }
 134
 135                 }
 136
 137                 SeekCount++;
 138
 139         }
 140
 141         // Check if the VEVENT is valid.
 142
 143         if (ValidBegin == true &&
 144                 ValidEnd == true &&
 145                 ValidDateTimeStamp == true &&
 146                 ValidUniqueID == true){
 147
 148                 return CALENDAROBJECTVALID_OK;
 149
 150         } else {
 151
 152                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 153
 154         }
 155
 156 }
 157
 158 void CalendarFreeBusyObject::ProcessData(){
 159
 160         // Process the data.
 161
 162         multimap<string,string> DataReceived;
 163         map<string,string> PropertyData;
 164         string *PropertyNameData = nullptr;
 165         int ObjectSeekCount = 0;
 166
 167         // Get the Date Time Stamp (DTSTAMP).
 168
 169         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DTSTAMP");
 170
 171         // Process the data from DTSTAMP.
 172
 173         if (DataReceived.begin() != DataReceived.end()){
 174
 175                 try {
 176                         DateTimeStampTokens = DataReceived.begin()->first.substr(8);
 177                 }
 178
 179                 catch(const out_of_range &oor){
 180                         // Do nothing as there is no data.
 181                 }
 182
 183                 DateTimeStampData = DataReceived.begin()->second;
 184
 185         }
 186
 187         // Get the Unique ID (UID).
 188
 189         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "UID");
 190
 191         // Process the data from UID.
 192
 193         if (DataReceived.begin() != DataReceived.end()){
 194
 195                 try {
 196                         UniqueIDTokens = DataReceived.begin()->first.substr(4);
 197                 }
 198
 199                 catch(const out_of_range &oor){
 200                         // Do nothing as there is no data.
 201                 }
 202
 203                 UniqueID = DataReceived.begin()->second;
 204
 205         }
 206
 207         // Process the data from CONTACT.
 208
 209         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "CONTACT");
 210
 211         ObjectSeekCount = 0;
 212
 213         for(multimap<string,string>::iterator iter = DataReceived.begin();
 214                 iter != DataReceived.end();
 215                 ++iter){
 216
 217                 ContactListTokens.push_back("");
 218                 ContactListAltRep.push_back("");
 219                 ContactListLanguage.push_back("");
 220                 ContactList.push_back("");
 221
 222                 bool TokenData = false;
 223                 string PropertyTokens;
 224
 225                 PropertyNameData = (string*)&iter->first;
 226
 227                 PropertyData = SplitValues(*PropertyNameData);
 228
 229                 for(map<string,string>::iterator dataiter = PropertyData.begin();
 230                         dataiter != PropertyData.end(); dataiter++){
 231
 232                         if (dataiter->first == "ALTREP"){
 233
 234                                 ContactListAltRep[ObjectSeekCount] = dataiter->second;
 235
 236                         } else if (dataiter->first == "LANGUAGE"){
 237
 238                                 ContactListLanguage[ObjectSeekCount] = dataiter->second;
 239
 240                         } else {
 241
 242                                 if (TokenData == false){
 243                                         TokenData = true;
 244                                 } else {
 245                                         PropertyTokens += ";";
 246                                 }
 247
 248                                 PropertyTokens += dataiter->first;
 249                                 PropertyTokens += "=";
 250                                 PropertyTokens += dataiter->second;
 251
 252                         }
 253
 254                 }
 255
 256                 if (PropertyTokens.size() > 0){
 257                         ContactListTokens[ObjectSeekCount] = PropertyTokens;
 258                 }
 259
 260                 ContactList[ObjectSeekCount] = iter->second;
 261
 262                 ObjectSeekCount++;
 263
 264         }
 265
 266         // Get the Date Time Start value.
 267
 268         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DTSTART");
 269
 270         // Process the data from DTSTART.
 271
 272         if (DataReceived.begin() != DataReceived.end()){
 273
 274                 bool TokenData = false;
 275                 string PropertyTokens;
 276
 277                 PropertyNameData = (string*)&DataReceived.begin()->first;
 278
 279                 PropertyData = SplitValues(*PropertyNameData);
 280
 281                 for(map<string,string>::iterator iter = PropertyData.begin();
 282                         iter != PropertyData.end(); iter++){
 283
 284                         if (iter->first == "VALUE"){
 285
 286                                 DateTimeStartDataValue = iter->second;
 287
 288                         } else if (iter->first == "TZID"){
 289
 290                                 DateTimeStartDataTimeZoneID = iter->second;
 291
 292                         } else {
 293
 294                                 if (TokenData == false){
 295                                         TokenData = true;
 296                                 } else {
 297                                         PropertyTokens += ";";
 298                                 }
 299
 300                                 PropertyTokens += iter->first;
 301                                 PropertyTokens += "=";
 302                                 PropertyTokens += iter->second;
 303
 304                         }
 305
 306                 }
 307
 308                 if (PropertyTokens.size() > 0){
 309                         DateTimeStartDataTokens = PropertyTokens;
 310                 }
 311
 312                 DateTimeStartData = DataReceived.begin()->second;
 313
 314         }
 315
 316         // Process the data from DTEND.
 317
 318         bool DateTimeEndProcessed = false;
 319
 320         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DTEND");
 321
 322         if (DataReceived.begin() != DataReceived.end()){
 323
 324                 bool TokenData = false;
 325                 string PropertyTokens;
 326
 327                 PropertyNameData = (string*)&DataReceived.begin()->first;
 328
 329                 PropertyData = SplitValues(*PropertyNameData);
 330
 331                 for(map<string,string>::iterator iter = PropertyData.begin();
 332                         iter != PropertyData.end(); iter++){
 333
 334                         if (iter->first == "VALUE"){
 335
 336                                 DateTimeEndDataValue = iter->second;
 337
 338                         } else if (iter->first == "TZID"){
 339
 340                                 DateTimeEndDataTimeZoneID = iter->second;
 341
 342                         } else {
 343
 344                                 if (TokenData == false){
 345                                         TokenData = true;
 346                                 } else {
 347                                         PropertyTokens += ";";
 348                                 }
 349
 350                                 PropertyTokens += iter->first;
 351                                 PropertyTokens += "=";
 352                                 PropertyTokens += iter->second;
 353
 354                         }
 355
 356                 }
 357
 358                 if (PropertyTokens.size() > 0){
 359                         DateTimeEndDataTokens = PropertyTokens;
 360                 }
 361
 362                 DateTimeEndData = DataReceived.begin()->second;
 363
 364                 DateTimeEndProcessed = true;
 365
 366         }
 367
 368         // Process the data from ORGANIZER.
 369
 370         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "ORGANIZER");
 371
 372         if (DataReceived.begin() != DataReceived.end()){
 373
 374                 bool TokenData = false;
 375                 string PropertyTokens;
 376
 377                 PropertyNameData = (string*)&DataReceived.begin()->first;
 378
 379                 PropertyData = SplitValues(*PropertyNameData);
 380
 381                 for(map<string,string>::iterator iter = PropertyData.begin();
 382                         iter != PropertyData.end(); iter++){
 383
 384                         if (iter->first == "CN"){
 385
 386                                 OrganiserDataCommonName = iter->second;
 387
 388                         } else if (iter->first == "DIR"){
 389
 390                                 OrganiserDataDirectoryEntry = iter->second;
 391
 392                         } else if (iter->first == "SENT-BY"){
 393
 394                                 OrganiserDataSentByParam = iter->second;
 395
 396                         } else if (iter->first == "LANGUAGE"){
 397
 398                                 OrganiserDataLanguage = iter->second;
 399
 400                         } else {
 401
 402                                 if (TokenData == false){
 403                                         TokenData = true;
 404                                 } else {
 405                                         PropertyTokens += ";";
 406                                 }
 407
 408                                 PropertyTokens += iter->first;
 409                                 PropertyTokens += "=";
 410                                 PropertyTokens += iter->second;
 411
 412                         }
 413
 414                 }
 415
 416                 if (PropertyTokens.size() > 0){
 417
 418                         OrganiserDataTokens = PropertyTokens;
 419
 420                 }
 421
 422                 OrganiserData = DataReceived.begin()->second;
 423
 424         }
 425
 426         // Process the data from URL.
 427
 428         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "URL");
 429
 430         if (DataReceived.begin() != DataReceived.end()){
 431
 432                 try {
 433                         URLDataTokens = DataReceived.begin()->first.substr(4);
 434                 }
 435
 436                 catch(const out_of_range &oor){
 437                         // Do nothing as there is no data.
 438                 }
 439
 440                 URLData = DataReceived.begin()->second;
 441
 442         }
 443
 444         // Process the data from ATTENDEE.
 445
 446         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "ATTENDEE");
 447
 448         ObjectSeekCount = 0;
 449
 450         for(multimap<string,string>::iterator iter = DataReceived.begin();
 451                 iter != DataReceived.end();
 452                 ++iter){
 453
 454                 AttendeeListMember.push_back("");
 455                 AttendeeListDelegatedFrom.push_back("");
 456                 AttendeeListDelegatedTo.push_back("");
 457                 AttendeeListRole.push_back("");
 458                 AttendeeListRSVP.push_back("");
 459                 AttendeeListDirectoryEntry.push_back("");
 460                 AttendeeListSentBy.push_back("");
 461                 AttendeeListCommonName.push_back("");
 462                 AttendeeListCalendarUserType.push_back("");
 463                 AttendeeListParticipationStatus.push_back("");
 464                 AttendeeListLanguage.push_back("");
 465                 AttendeeListTokens.push_back("");
 466                 AttendeeList.push_back("");
 467
 468                 bool TokenData = false;
 469                 string PropertyTokens;
 470
 471                 PropertyNameData = (string*)&iter->first;
 472
 473                 PropertyData = SplitValues(*PropertyNameData);
 474
 475                 for(map<string,string>::iterator dataiter = PropertyData.begin();
 476                         dataiter != PropertyData.end(); dataiter++){
 477
 478                         if (dataiter->first == "CUTYPE"){
 479
 480                                 AttendeeListCalendarUserType[ObjectSeekCount] = dataiter->second;
 481
 482                         } else if (dataiter->first == "MEMBER"){
 483
 484                                 AttendeeListMember[ObjectSeekCount] = dataiter->second;
 485
 486                         } else if (dataiter->first == "ROLE"){
 487
 488                                 AttendeeListRole[ObjectSeekCount] = dataiter->second;
 489
 490                         } else if (dataiter->first == "PARTSTAT"){
 491
 492                                 AttendeeListParticipationStatus[ObjectSeekCount] = dataiter->second;
 493
 494                         } else if (dataiter->first == "RSVP"){
 495
 496                                 AttendeeListRSVP[ObjectSeekCount] = dataiter->second;
 497
 498                         } else if (dataiter->first == "DELEGATED-TO"){
 499
 500                                 AttendeeListDelegatedTo[ObjectSeekCount] = dataiter->second;
 501
 502                         } else if (dataiter->first == "DELEGATED-FROM"){
 503
 504                                 AttendeeListDelegatedFrom[ObjectSeekCount] = dataiter->second;
 505
 506                         } else if (dataiter->first == "SENT-BY"){
 507
 508                                 AttendeeListSentBy[ObjectSeekCount] = dataiter->second;
 509
 510                         } else if (dataiter->first == "CN"){
 511
 512                                 AttendeeListCommonName[ObjectSeekCount] = dataiter->second;
 513
 514                         } else if (dataiter->first == "DIR"){
 515
 516                                 AttendeeListDirectoryEntry[ObjectSeekCount] = dataiter->second;
 517
 518                         } else if (dataiter->first == "LANGUAGE"){
 519
 520                                 AttendeeListLanguage[ObjectSeekCount] = dataiter->second;
 521
 522                         } else {
 523
 524                                 if (TokenData == false){
 525                                         TokenData = true;
 526                                 } else {
 527                                         PropertyTokens += ";";
 528                                 }
 529
 530                                 PropertyTokens += dataiter->first;
 531                                 PropertyTokens += "=";
 532                                 PropertyTokens += dataiter->second;
 533
 534                         }
 535
 536                 }
 537
 538                 if (PropertyTokens.size() > 0){
 539                         AttendeeListTokens[ObjectSeekCount] = PropertyTokens;
 540                 }
 541
 542                 AttendeeList[ObjectSeekCount] = iter->second;
 543
 544                 ObjectSeekCount++;
 545
 546         }
 547
 548         // Process the data from COMMENT.
 549
 550         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "COMMENT");
 551
 552         ObjectSeekCount = 0;
 553
 554         for(multimap<string,string>::iterator iter = DataReceived.begin();
 555                 iter != DataReceived.end();
 556                 ++iter){
 557
 558                 CommentListTokens.push_back("");
 559                 CommentListAltRep.push_back("");
 560                 CommentListLanguage.push_back("");
 561                 CommentList.push_back("");
 562
 563                 bool TokenData = false;
 564                 string PropertyTokens;
 565
 566                 PropertyNameData = (string*)&iter->first;
 567
 568                 PropertyData = SplitValues(*PropertyNameData);
 569
 570                 for(map<string,string>::iterator dataiter = PropertyData.begin();
 571                         dataiter != PropertyData.end(); dataiter++){
 572
 573                         if (dataiter->first == "ALTREP"){
 574
 575                                 CommentListAltRep[ObjectSeekCount] = dataiter->second;
 576
 577                         } else if (dataiter->first == "LANGUAGE"){
 578
 579                                 CommentListLanguage[ObjectSeekCount] = dataiter->second;
 580
 581                         } else {
 582
 583                                 if (TokenData == false){
 584                                         TokenData = true;
 585                                 } else {
 586                                         PropertyTokens += ";";
 587                                 }
 588
 589                                 PropertyTokens += dataiter->first;
 590                                 PropertyTokens += "=";
 591                                 PropertyTokens += dataiter->second;
 592
 593                         }
 594
 595                 }
 596
 597                 if (PropertyTokens.size() > 0){
 598                         CommentListTokens[ObjectSeekCount] = PropertyTokens;
 599                 }
 600
 601                 CommentList[ObjectSeekCount] = iter->second;
 602
 603                 ObjectSeekCount++;
 604
 605         }
 606
 607         // Process the data from FREEBUSY.
 608
 609         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "FREEBUSY");
 610
 611         ObjectSeekCount = 0;
 612
 613         for(multimap<string,string>::iterator iter = DataReceived.begin();
 614                 iter != DataReceived.end();
 615                 ++iter){
 616
 617                 FreeBusyListTokens.push_back("");
 618                 FreeBusyListType.push_back("");
 619                 FreeBusyList.push_back("");
 620
 621                 bool TokenData = false;
 622                 string PropertyTokens;
 623
 624                 PropertyNameData = (string*)&iter->first;
 625
 626                 PropertyData = SplitValues(*PropertyNameData);
 627
 628                 for(map<string,string>::iterator dataiter = PropertyData.begin();
 629                         dataiter != PropertyData.end(); dataiter++){
 630
 631                         if (dataiter->first == "FBTYPE"){
 632
 633                                 FreeBusyListType[ObjectSeekCount] = dataiter->second;
 634
 635                         } else {
 636
 637                                 if (TokenData == false){
 638                                         TokenData = true;
 639                                 } else {
 640                                         PropertyTokens += ";";
 641                                 }
 642
 643                                 PropertyTokens += dataiter->first;
 644                                 PropertyTokens += "=";
 645                                 PropertyTokens += dataiter->second;
 646
 647                         }
 648
 649                 }
 650
 651                 if (PropertyTokens.size() > 0){
 652                         FreeBusyListTokens[ObjectSeekCount] = PropertyTokens;
 653                 }
 654
 655                 FreeBusyList[ObjectSeekCount] = iter->second;
 656
 657                 ObjectSeekCount++;
 658
 659         }
 660
 661         // Process the data from REQUEST-STATUS.
 662
 663         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "REQUEST-STATUS");
 664
 665         ObjectSeekCount = 0;
 666
 667         for(multimap<string,string>::iterator iter = DataReceived.begin();
 668                 iter != DataReceived.end();
 669                 ++iter){
 670
 671                 RequestStatusTokens.push_back("");
 672                 RequestStatusLanguage.push_back("");
 673                 RequestStatusData.push_back("");
 674
 675                 bool TokenData = false;
 676                 string PropertyTokens;
 677
 678                 PropertyNameData = (string*)&iter->first;
 679
 680                 PropertyData = SplitValues(*PropertyNameData);
 681
 682                 for(map<string,string>::iterator dataiter = PropertyData.begin();
 683                         dataiter != PropertyData.end(); dataiter++){
 684
 685                         if (dataiter->first == "LANGUAGE"){
 686
 687                                 RequestStatusLanguage[ObjectSeekCount] = dataiter->second;
 688
 689                         } else {
 690
 691                                 if (TokenData == false){
 692                                         TokenData = true;
 693                                 } else {
 694                                         PropertyTokens += ";";
 695                                 }
 696
 697                                 PropertyTokens += dataiter->first;
 698                                 PropertyTokens += "=";
 699                                 PropertyTokens += dataiter->second;
 700
 701                         }
 702
 703                 }
 704
 705                 if (PropertyTokens.size() > 0){
 706                         RequestStatusTokens[ObjectSeekCount] = PropertyTokens;
 707                 }
 708
 709                 RequestStatusData[ObjectSeekCount] = iter->second;
 710
 711                 ObjectSeekCount++;
 712
 713         }
 714
 715         ObjectSeekCount = 0;
 716
 717         // Process data from X-*
 718
 719         for(vector<string>::iterator iter = ObjectName.begin();
 720                 iter != ObjectName.end(); ++iter){
 721
 722                 bool TokenData = false;
 723                 string PropertyTokens;
 724
 725                 if (iter->substr(0,2) == "X-" &&
 726                         iter->size() > 2){
 727
 728                         XTokensData.push_back(ObjectData[ObjectSeekCount]);
 729                         XTokensDataTokens.push_back(ObjectName[ObjectSeekCount]);
 730
 731                 }
 732
 733                 ObjectSeekCount++;
 734
 735         }
 736
 737 }