Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
Added code to check for an EMAIL VALARM.
[xestiacalendar/.git] / source / objects / calendarevent / CalendarEvent.cpp
index 3e25e86..7a23341 100644 (file)
@@ -1456,9 +1456,10 @@ void CalendarEventObject::ProcessData(){
        
        // Process Alarm section.
        
-       ProcessAlarms();
+       //ProcessAlarms();
        
        int SeekCount = 0;
+       int AlarmObjectCount = 0;
        
        bool AlarmActionFound = false;
        
@@ -1471,6 +1472,9 @@ void CalendarEventObject::ProcessData(){
        
                bool AlarmActionFound = false;
                bool AlarmTriggerFound = false;
+               bool AlarmDurationFound = false;
+               bool AlarmDescriptionFound = false;
+               bool AlarmSummaryFound = false;
                        
                DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], 
                                &EventAlarmData[SeekCount], false, "ACTION");
@@ -1524,7 +1528,7 @@ void CalendarEventObject::ProcessData(){
                
                // Process the data from TRIGGER.
                
-               DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "TRIGGER");
+               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "TRIGGER");
        
                if (DataReceived.begin() != DataReceived.end()){
        
@@ -1567,14 +1571,364 @@ void CalendarEventObject::ProcessData(){
                        }
                
                        NewAlarmData.TriggerData = DataReceived.begin()->second;
+                       AlarmTriggerFound = true;
+               
+               }
+               
+               // Process the data from DESCRIPTION.
+               
+               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "DESCRIPTION");
+       
+               if (DataReceived.begin() != DataReceived.end() &&
+                       (NewAlarmData.AlarmType == CALENDARALARM_DISPLAY ||
+                       NewAlarmData.AlarmType == CALENDARALARM_EMAIL)){
+       
+                       bool TokenData = false;
+                       string PropertyTokens;
+               
+                       PropertyNameData = (string*)&DataReceived.begin()->first;
+               
+                       PropertyData = SplitValues(*PropertyNameData);
+               
+                       for(map<string,string>::iterator iter = PropertyData.begin();
+                               iter != PropertyData.end(); iter++){
+                       
+                               if (iter->first == "ALTREP"){
+                               
+                                       NewAlarmData.DescriptionAltRep = iter->second;
+                               
+                               } else if (iter->first == "LANGUAGE"){
+                               
+                                       NewAlarmData.DescriptionLanguage = iter->second;
+                               
+                               } else {
+                               
+                                       if (TokenData == false){
+                                               TokenData = true;
+                                       } else {
+                                               PropertyTokens += ";";
+                                       }
+                               
+                                       PropertyTokens += iter->first;
+                                       PropertyTokens += "=";
+                                       PropertyTokens += iter->second;
+                               
+                               }
+                               
+                       }
+               
+                       if (PropertyTokens.size() > 0){
+                               NewAlarmData.DescriptionTokens = PropertyTokens;
+                       }
+               
+                       NewAlarmData.DescriptionData = DataReceived.begin()->second;
+                       AlarmDescriptionFound = true;
+               
+               }
+               
+               // Process data from SUMMARY.
+               
+               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "SUMMARY");
+       
+               if (DataReceived.begin() != DataReceived.end() &&
+                       NewAlarmData.AlarmType == CALENDARALARM_EMAIL){
+       
+                       bool TokenData = false;
+                       string PropertyTokens;
+               
+                       PropertyNameData = (string*)&DataReceived.begin()->first;
+               
+                       PropertyData = SplitValues(*PropertyNameData);
+               
+                       for(map<string,string>::iterator iter = PropertyData.begin();
+                               iter != PropertyData.end(); iter++){
+                       
+                               if (iter->first == "ALTREP"){
+                               
+                                       NewAlarmData.SummaryAltRep = iter->second;
+                               
+                               } else if (iter->first == "LANGUAGE"){
+                               
+                                       NewAlarmData.SummaryLanguage = iter->second;
+                               
+                               } else {
+                               
+                                       if (TokenData == false){
+                                               TokenData = true;
+                                       } else {
+                                               PropertyTokens += ";";
+                                       }
+                               
+                                       PropertyTokens += iter->first;
+                                       PropertyTokens += "=";
+                                       PropertyTokens += iter->second;
+                               
+                               }
+                               
+                       }
+               
+                       if (PropertyTokens.size() > 0){
+                               NewAlarmData.SummaryTokens = PropertyTokens;
+                       }
+               
+                       NewAlarmData.SummaryData = DataReceived.begin()->second;
+                       AlarmSummaryFound = true;
+               
+               }
+               
+               // Process data from DURATION.
+               
+               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "DURATION");
+               
+               if (DataReceived.begin() != DataReceived.end()){
+       
+                       try {
+                               NewAlarmData.DurationTokens = DataReceived.begin()->first.substr(9);
+                       }
+               
+                       catch(const out_of_range &oor){
+                               // Do nothing as there is no data.
+                       }               
+               
+                       NewAlarmData.DurationData = DataReceived.begin()->second;
+                       AlarmDurationFound = true;
+               
+               }
+               
+               // Process data from REPEAT.
+               
+               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "REPEAT");
+               
+               if (DataReceived.begin() != DataReceived.end() && AlarmDurationFound == true){
+       
+                       try {
+                               NewAlarmData.RepeatTokens = DataReceived.begin()->first.substr(7);
+                       }
+               
+                       catch(const out_of_range &oor){
+                               // Do nothing as there is no data.
+                       }               
+               
+                       NewAlarmData.RepeatData = DataReceived.begin()->second;
+               
+               } else {
+                       
+                       NewAlarmData.DurationData.clear();
+                       NewAlarmData.DurationTokens.clear();
+                       
+               }
+               
+               // Process data from ATTENDEE.
+               
+               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], true, "ATTENDEE");
+       
+               ObjectSeekCount = 0;
+       
+               for(multimap<string,string>::iterator iter = DataReceived.begin(); 
+                       iter != DataReceived.end(); 
+                       ++iter){
+                       
+                       NewAlarmData.AttendeeListMember.push_back("");
+                       NewAlarmData.AttendeeListDelegatedFrom.push_back("");
+                       NewAlarmData.AttendeeListDelegatedTo.push_back("");
+                       NewAlarmData.AttendeeListRole.push_back("");
+                       NewAlarmData.AttendeeListRSVP.push_back("");
+                       NewAlarmData.AttendeeListDirectoryEntry.push_back("");
+                       NewAlarmData.AttendeeListSentBy.push_back("");
+                       NewAlarmData.AttendeeListCommonName.push_back("");
+                       NewAlarmData.AttendeeListCalendarUserType.push_back("");
+                       NewAlarmData.AttendeeListParticipationStatus.push_back("");
+                       NewAlarmData.AttendeeListLanguage.push_back("");
+                       NewAlarmData.AttendeeListTokens.push_back("");
+                       NewAlarmData.AttendeeList.push_back("");
+                       
+                       bool TokenData = false;
+                       string PropertyTokens;
+               
+                       PropertyNameData = (string*)&iter->first;
+               
+                       PropertyData = SplitValues(*PropertyNameData);
+                       
+                       for(map<string,string>::iterator dataiter = PropertyData.begin();
+                               dataiter != PropertyData.end(); dataiter++){
+                       
+                               if (dataiter->first == "CUTYPE"){
+                               
+                                       NewAlarmData.AttendeeListCalendarUserType[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "MEMBER"){
+                               
+                                       NewAlarmData.AttendeeListMember[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "ROLE"){
+                               
+                                       NewAlarmData.AttendeeListRole[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "PARTSTAT"){
+                               
+                                       NewAlarmData.AttendeeListParticipationStatus[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "RSVP"){
+                               
+                                       NewAlarmData.AttendeeListRSVP[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "DELEGATED-TO"){
+                               
+                                       NewAlarmData.AttendeeListDelegatedTo[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "DELEGATED-FROM"){
+                               
+                                       NewAlarmData.AttendeeListDelegatedFrom[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "SENT-BY"){
+                               
+                                       NewAlarmData.AttendeeListSentBy[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "CN"){
+                               
+                                       NewAlarmData.AttendeeListCommonName[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "DIR"){
+                               
+                                       NewAlarmData.AttendeeListDirectoryEntry[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "LANGUAGE"){
+                               
+                                       NewAlarmData.AttendeeListLanguage[ObjectSeekCount] = dataiter->second;
+                               
+                               } else {
+                               
+                                       if (TokenData == false){
+                                               TokenData = true;
+                                       } else {
+                                               PropertyTokens += ";";
+                                       }
+                               
+                                       PropertyTokens += dataiter->first;
+                                       PropertyTokens += "=";
+                                       PropertyTokens += dataiter->second;
+                               
+                               }
+                               
+                       }
+               
+                       if (PropertyTokens.size() > 0){
+                               NewAlarmData.AttendeeListTokens[ObjectSeekCount] = PropertyTokens;
+                       }
+                       
+                       NewAlarmData.AttendeeList[ObjectSeekCount] = iter->second;
+               
+                       ObjectSeekCount++;
+               
+               }
+               
+               // Process data from ATTACH.
+               
+               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], true, "ATTACH");
+       
+               ObjectSeekCount = 0;
+               
+               for(multimap<string,string>::iterator iter = DataReceived.begin(); 
+                       iter != DataReceived.end();
+                       ++iter){
+               
+                       NewAlarmData.AttachListEncoding.push_back("");
+                       NewAlarmData.AttachListValue.push_back("");
+                       NewAlarmData.AttachListFormatType.push_back("");
+                       NewAlarmData.AttachListTokens.push_back("");
+                       NewAlarmData.AttachList.push_back("");
+                       
+                       bool TokenData = false;
+                       string PropertyTokens;
+               
+                       PropertyNameData = (string*)&iter->first;
+               
+                       PropertyData = SplitValues(*PropertyNameData);
+                       
+                       for(map<string,string>::iterator dataiter = PropertyData.begin();
+                               dataiter != PropertyData.end(); dataiter++){
+                       
+                               if (dataiter->first == "ENCODING"){
+                               
+                                       NewAlarmData.AttachListEncoding[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "VALUE"){
+                               
+                                       NewAlarmData.AttachListValue[ObjectSeekCount] = dataiter->second;
+                               
+                               } else if (dataiter->first == "FMTTYPE"){
+                               
+                                       NewAlarmData.AttachListFormatType[ObjectSeekCount] = dataiter->second;
+                               
+                               } else {
+                               
+                                       if (TokenData == false){
+                                               TokenData = true;
+                                       } else {
+                                               PropertyTokens += ";";
+                                       }
+                               
+                                       PropertyTokens += dataiter->first;
+                                       PropertyTokens += "=";
+                                       PropertyTokens += dataiter->second;
+                               
+                               }
+                               
+                       }
+               
+                       if (PropertyTokens.size() > 0){
+                               NewAlarmData.AttachListTokens[ObjectSeekCount] = PropertyTokens;
+                       }
+                       
+                       NewAlarmData.AttachList[ObjectSeekCount] = iter->second;
+               
+                       ObjectSeekCount++;
+               
+               }
+               
+               // Process data from X-*
+               
+               AlarmObjectCount = 0;
+               
+               for(vector<string>::iterator xtokeniter = EventAlarmName[SeekCount].begin(); 
+                       xtokeniter != EventAlarmName[SeekCount].end(); ++xtokeniter){
+                       
+                       bool TokenData = false;
+                       string PropertyTokens;
+               
+                       if (xtokeniter->substr(0,2) == "X-" &&
+                               xtokeniter->size() > 2){
+                       
+                               NewAlarmData.XTokensData.push_back(EventAlarmData[SeekCount][AlarmObjectCount]);
+                               NewAlarmData.XTokensDataTokens.push_back(EventAlarmName[SeekCount][AlarmObjectCount]);
+                               
+                       }
+               
+                       AlarmObjectCount++;
                
                }
                
                if (NewAlarmData.AlarmType == CALENDARALARM_AUDIO &&
-                       AlarmActionFound == true){
+                       AlarmActionFound == true &&
+                       AlarmTriggerFound == true){
                
                        CalendarAlarmData.push_back(NewAlarmData);
                        
+               } else if (NewAlarmData.AlarmType == CALENDARALARM_DISPLAY &&
+                       AlarmActionFound == true &&
+                       AlarmTriggerFound == true &&
+                       AlarmDescriptionFound == true){
+
+                       CalendarAlarmData.push_back(NewAlarmData);
+                               
+               } else if (NewAlarmData.AlarmType == CALENDARALARM_EMAIL &&
+                       AlarmActionFound == true &&
+                       AlarmTriggerFound == true &&
+                       AlarmDescriptionFound == true &&
+                       AlarmSummaryFound == true){
+               
+                       CalendarAlarmData.push_back(NewAlarmData);
+                               
                }
                        
                SeekCount++;
Xestia Software Development
Yn Maystri
© 2006 - 2019 Xestia Software Development
Software

Xestia Address Book
Xestia Calendar
Development

Xestia Gelforn
Everything else

About
News
Privacy Policy