src/Calendar/CalendarFilter.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include "CalendarFilter.h"
  19 #include <Commons/Exception.h>
  20 #include <sstream>
  21 #include "CalendarUtility.h"
  22 #include <Logger.h>
  23
  24 using namespace WrtDeviceApis::Commons;
  25
  26 namespace DeviceAPI {
  27 namespace Calendar {
  28
  29 std::map<std::string, unsigned int> CalendarFilter::m_eventAttributeMap = {
  30     {CALENDAR_FILTER_ATTRIBUTE_ID_UID,                          _calendar_event.id},
  31     {CALENDAR_FILTER_ATTRIBUTE_LAST_MODIFIED_DATE,              _calendar_event.last_modified_time},
  32     {CALENDAR_FILTER_ATTRIBUTE_DESCRIPTION,                     _calendar_event.description},
  33     {CALENDAR_FILTER_ATTRIBUTE_SUMMARY,                         _calendar_event.summary},
  34     {CALENDAR_FILTER_ATTRIBUTE_START_DATE,                      _calendar_event.start_time},
  35     {CALENDAR_FILTER_ATTRIBUTE_LOCATION,                        _calendar_event.location},
  36     {CALENDAR_FILTER_ATTRIBUTE_LATITUDE,                        _calendar_event.latitude},
  37     {CALENDAR_FILTER_ATTRIBUTE_LONGITUDE,                       _calendar_event.longitude},
  38     {CALENDAR_FILTER_ATTRIBUTE_ORGANIZER,                       _calendar_event.organizer_name},
  39     {CALENDAR_FILTER_ATTRIBUTE_VISIBILITY,                      _calendar_event.sensitivity},
  40     {CALENDAR_FILTER_ATTRIBUTE_STATUS,                          _calendar_event.event_status},
  41     {CALENDAR_FILTER_ATTRIBUTE_ALARMS,                          _calendar_event.has_alarm},
  42     {CALENDAR_FILTER_ATTRIBUTE_CATEGORIES,                      _calendar_event.categories},
  43     {CALENDAR_FILTER_ATTRIBUTE_PRIORITY,                        _calendar_event.priority},
  44     {CALENDAR_FILTER_ATTRIBUTE_IS_DETACHED,                     _calendar_event.original_event_id},
  45     {CALENDAR_FILTER_ATTRIBUTE_IS_ALL_DAY,                      _calendar_event.is_allday},
  46     {CALENDAR_FILTER_ATTRIBUTE_ATTENDEES,                       _calendar_event.has_attendee},
  47     {CALENDAR_FILTER_ATTRIBUTE_END_DATE,                        _calendar_event.end_time},
  48     {CALENDAR_FILTER_ATTRIBUTE_AVAILABILITY,                    _calendar_event.busy_status},
  49     {CALENDAR_FILTER_ATTRIBUTE_RECURRENCE_RULE,                 _calendar_event.freq}
  50 };
  51
  52 std::map<std::string, unsigned int> CalendarFilter::m_normalInstanceAttributeMap = {
  53     {CALENDAR_FILTER_ATTRIBUTE_ID_UID,                          _calendar_instance_normal_calendar_book.event_id},
  54     {CALENDAR_FILTER_ATTRIBUTE_LAST_MODIFIED_DATE,              _calendar_instance_normal_calendar_book.last_modified_time},
  55     {CALENDAR_FILTER_ATTRIBUTE_DESCRIPTION,                     _calendar_instance_normal_calendar_book.description},
  56     {CALENDAR_FILTER_ATTRIBUTE_SUMMARY,                         _calendar_instance_normal_calendar_book.summary},
  57     {CALENDAR_FILTER_ATTRIBUTE_START_DATE,                      _calendar_instance_normal_calendar_book.start_time},
  58     {CALENDAR_FILTER_ATTRIBUTE_LOCATION,                        _calendar_instance_normal_calendar_book.location},
  59     {CALENDAR_FILTER_ATTRIBUTE_LATITUDE,                        _calendar_instance_normal_calendar_book.latitude},
  60     {CALENDAR_FILTER_ATTRIBUTE_LONGITUDE,                       _calendar_instance_normal_calendar_book.longitude},
  61     //{CALENDAR_FILTER_ATTRIBUTE_ORGANIZER,                       _calendar_instance_normal_calendar_book.organizer_name},
  62     {CALENDAR_FILTER_ATTRIBUTE_VISIBILITY,                      _calendar_instance_normal_calendar_book.sensitivity},
  63     {CALENDAR_FILTER_ATTRIBUTE_STATUS,                          _calendar_instance_normal_calendar_book.event_status},
  64     {CALENDAR_FILTER_ATTRIBUTE_ALARMS,                          _calendar_instance_normal_calendar_book.has_alarm},
  65     //{CALENDAR_FILTER_ATTRIBUTE_CATEGORIES,                      _calendar_instance_normal_calendar_book.categories},
  66     {CALENDAR_FILTER_ATTRIBUTE_PRIORITY,                        _calendar_instance_normal_calendar_book.priority},
  67     {CALENDAR_FILTER_ATTRIBUTE_IS_DETACHED,                     _calendar_instance_normal_calendar_book.original_event_id},
  68     /*{CALENDAR_FILTER_ATTRIBUTE_IS_ALL_DAY,                      _calendar_instance_normal_calendar_book.is_allday}, no meaning for instance. */
  69     //{CALENDAR_FILTER_ATTRIBUTE_ATTENDEES,                       _calendar_instance_normal_calendar_book.has_attendee},
  70     {CALENDAR_FILTER_ATTRIBUTE_END_DATE,                        _calendar_instance_normal_calendar_book.end_time},
  71     {CALENDAR_FILTER_ATTRIBUTE_AVAILABILITY,                    _calendar_instance_normal_calendar_book.busy_status},
  72     {CALENDAR_FILTER_ATTRIBUTE_RECURRENCE_RULE,                 _calendar_instance_normal_calendar_book.has_rrule}
  73 };
  74
  75 std::map<std::string, unsigned int> CalendarFilter::m_alldayInstanceAttributeMap = {
  76     {CALENDAR_FILTER_ATTRIBUTE_ID_UID,                          _calendar_instance_allday_calendar_book.event_id},
  77     {CALENDAR_FILTER_ATTRIBUTE_LAST_MODIFIED_DATE,              _calendar_instance_allday_calendar_book.last_modified_time},
  78     {CALENDAR_FILTER_ATTRIBUTE_DESCRIPTION,                     _calendar_instance_allday_calendar_book.description},
  79     {CALENDAR_FILTER_ATTRIBUTE_SUMMARY,                         _calendar_instance_allday_calendar_book.summary},
  80     {CALENDAR_FILTER_ATTRIBUTE_START_DATE,                      _calendar_instance_allday_calendar_book.start_time},
  81     {CALENDAR_FILTER_ATTRIBUTE_LOCATION,                        _calendar_instance_allday_calendar_book.location},
  82     {CALENDAR_FILTER_ATTRIBUTE_LATITUDE,                        _calendar_instance_allday_calendar_book.latitude},
  83     {CALENDAR_FILTER_ATTRIBUTE_LONGITUDE,                       _calendar_instance_allday_calendar_book.longitude},
  84     //{CALENDAR_FILTER_ATTRIBUTE_ORGANIZER,                       _calendar_instance_allday_calendar_book.organizer_name},
  85     {CALENDAR_FILTER_ATTRIBUTE_VISIBILITY,                      _calendar_instance_allday_calendar_book.sensitivity},
  86     {CALENDAR_FILTER_ATTRIBUTE_STATUS,                          _calendar_instance_allday_calendar_book.event_status},
  87     {CALENDAR_FILTER_ATTRIBUTE_ALARMS,                          _calendar_instance_allday_calendar_book.has_alarm},
  88     //{CALENDAR_FILTER_ATTRIBUTE_CATEGORIES,                      _calendar_instance_allday_calendar_book.categories},
  89     {CALENDAR_FILTER_ATTRIBUTE_PRIORITY,                        _calendar_instance_allday_calendar_book.priority},
  90     {CALENDAR_FILTER_ATTRIBUTE_IS_DETACHED,                     _calendar_instance_allday_calendar_book.original_event_id},
  91     /*{CALENDAR_FILTER_ATTRIBUTE_IS_ALL_DAY,                      _calendar_instance_allday_calendar_book.is_allday}, no meaning for instance. */
  92     //{CALENDAR_FILTER_ATTRIBUTE_ATTENDEES,                       _calendar_instance_allday_calendar_book.has_attendee},
  93     {CALENDAR_FILTER_ATTRIBUTE_END_DATE,                        _calendar_instance_allday_calendar_book.end_time},
  94     {CALENDAR_FILTER_ATTRIBUTE_AVAILABILITY,                    _calendar_instance_allday_calendar_book.busy_status},
  95     {CALENDAR_FILTER_ATTRIBUTE_RECURRENCE_RULE,                 _calendar_instance_allday_calendar_book.has_rrule}
  96 };
  97
  98 std::map<std::string, unsigned int> CalendarFilter::m_taskAttributeMap = {
  99     {CALENDAR_FILTER_ATTRIBUTE_ID,                              _calendar_todo.id},
 100     {CALENDAR_FILTER_ATTRIBUTE_LAST_MODIFIED_DATE,              _calendar_todo.last_modified_time},
 101     {CALENDAR_FILTER_ATTRIBUTE_DESCRIPTION,                     _calendar_todo.description},
 102     {CALENDAR_FILTER_ATTRIBUTE_SUMMARY,                         _calendar_todo.summary},
 103     {CALENDAR_FILTER_ATTRIBUTE_START_DATE,                      _calendar_todo.start_time},
 104     {CALENDAR_FILTER_ATTRIBUTE_LOCATION,                        _calendar_todo.location},
 105     {CALENDAR_FILTER_ATTRIBUTE_LATITUDE,                        _calendar_todo.latitude},
 106     {CALENDAR_FILTER_ATTRIBUTE_LONGITUDE,                       _calendar_todo.longitude},
 107     {CALENDAR_FILTER_ATTRIBUTE_ORGANIZER,                       _calendar_todo.organizer_name},
 108     {CALENDAR_FILTER_ATTRIBUTE_VISIBILITY,                      _calendar_todo.sensitivity},
 109     {CALENDAR_FILTER_ATTRIBUTE_STATUS,                          _calendar_todo.todo_status},
 110     {CALENDAR_FILTER_ATTRIBUTE_ALARMS,                          _calendar_todo.has_alarm},
 111     {CALENDAR_FILTER_ATTRIBUTE_CATEGORIES,                      _calendar_todo.categories},
 112     {CALENDAR_FILTER_ATTRIBUTE_PRIORITY,                        _calendar_todo.priority},
 113     {CALENDAR_FILTER_ATTRIBUTE_DUE_DATE,                        _calendar_todo.due_time},
 114     {CALENDAR_FILTER_ATTRIBUTE_COMPLETED_DATE,                  _calendar_todo.completed_time},
 115     {CALENDAR_FILTER_ATTRIBUTE_PROGRESS,                        _calendar_todo.progress},
 116     {CALENDAR_FILTER_ATTRIBUTE_IS_ALL_DAY,                      _calendar_todo.is_allday},
 117     {CALENDAR_FILTER_ATTRIBUTE_ATTENDEES,                       _calendar_todo.has_attendee}
 118 };
 119
 120 CalendarFilter::CalendarFilter()
 121 {
 122     m_type = CalendarEvent::UNDEFINED_TYPE;
 123     m_query = NULL;
 124     m_filter = NULL;
 125     m_recordList = NULL;
 126     m_recordCount = 0;
 127         m_normalInstanceQuery = NULL;
 128         m_normalInstanceFilter = NULL;
 129     m_normalInstanceRecordList = NULL;
 130     m_normalInstanceRecordCount = 0;
 131         m_alldayInstanceQuery = NULL;
 132         m_alldayInstanceFilter = NULL;
 133     m_alldayInstanceRecordList = NULL;
 134     m_alldayInstanceRecordCount = 0;
 135         m_enableInstanceSearch = false;
 136 }
 137
 138 CalendarFilter::~CalendarFilter()
 139 {
 140     LoggerD("Clear internal structs for filters.");
 141     if(m_query) {
 142         if(CALENDAR_ERROR_NONE!=calendar_query_destroy(m_query)) LoggerW("Filter destroy failed.");
 143     }
 144     if(m_filter) {
 145         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(m_filter)) LoggerW("Filter destroy failed.");
 146     }
 147     if(m_normalInstanceQuery) {
 148         if(CALENDAR_ERROR_NONE!=calendar_query_destroy(m_normalInstanceQuery)) LoggerW("Filter destroy failed.");
 149     }
 150     if(m_normalInstanceFilter) {
 151         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(m_normalInstanceFilter)) LoggerW("Filter destroy failed.");
 152     }
 153     if(m_alldayInstanceQuery) {
 154         if(CALENDAR_ERROR_NONE!=calendar_query_destroy(m_alldayInstanceQuery)) LoggerW("Filter destroy failed.");
 155     }
 156     if(m_alldayInstanceFilter) {
 157         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(m_alldayInstanceFilter)) LoggerW("Filter destroy failed.");
 158     }
 159
 160     // Child record will be freed in the caller function.
 161     if(m_recordList) {
 162         if(CALENDAR_ERROR_NONE!=calendar_list_destroy(m_recordList, false)) LoggerW("List destroy failed.");
 163     }
 164
 165         if(m_normalInstanceRecordList) {
 166                 if(CALENDAR_ERROR_NONE!=calendar_list_destroy(m_normalInstanceRecordList, true)) LoggerW("List destroy failed.");
 167         }
 168         if(m_alldayInstanceRecordList) {
 169                 if(CALENDAR_ERROR_NONE!=calendar_list_destroy(m_alldayInstanceRecordList, true)) LoggerW("List destroy failed.");
 170         }
 171 }
 172
 173 void CalendarFilter::visitPreComposite(DeviceAPI::Tizen::FilterType& type, int depth)
 174 {
 175         LoggerD("Composite pre with type: "<<type<<", depth: "<<depth);
 176
 177         calendar_filter_h compositeFilter = NULL;
 178         calendar_filter_h normalInstanceCompositeFilter = NULL;
 179         calendar_filter_h alldayInstanceCompositeFilter = NULL;
 180     if(CalendarEvent::TASK_TYPE==m_type) {
 181                 if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_todo._uri, &compositeFilter)) LoggerW("Filter creation failed.");
 182         } else {
 183                 if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_event._uri, &compositeFilter)) LoggerW("Filter creation failed.");
 184         }
 185         m_compositeFilters.push_back(compositeFilter);
 186
 187         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_instance_normal_calendar_book._uri, &normalInstanceCompositeFilter)) LoggerW("Filter creation failed.");
 188         m_normalInstanceCompositeFilters.push_back(normalInstanceCompositeFilter);
 189         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_instance_allday_calendar_book._uri, &alldayInstanceCompositeFilter)) LoggerW("Filter creation failed.");
 190         m_alldayInstanceCompositeFilters.push_back(alldayInstanceCompositeFilter);
 191 }
 192
 193 void CalendarFilter::visitInComposite(DeviceAPI::Tizen::FilterType& type, int depth)
 194 {
 195         LoggerI("Composite in with type: "<<type<<", depth: "<<depth);
 196         if(type == DeviceAPI::Tizen::UNION_FILTER) {
 197                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_compositeFilters[depth], CALENDAR_FILTER_OPERATOR_OR)) LoggerW("Filter add failed.");
 198                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_normalInstanceCompositeFilters[depth], CALENDAR_FILTER_OPERATOR_OR)) LoggerW("Filter add failed.");
 199                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_alldayInstanceCompositeFilters[depth], CALENDAR_FILTER_OPERATOR_OR)) LoggerW("Filter add failed.");
 200         } else if(type == DeviceAPI::Tizen::INTERSECTION_FILTER) {
 201                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_compositeFilters[depth], CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 202                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_normalInstanceCompositeFilters[depth], CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 203                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_alldayInstanceCompositeFilters[depth], CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 204         }
 205 }
 206
 207 void CalendarFilter::visitPostComposite(DeviceAPI::Tizen::FilterType& type, int depth)
 208 {
 209         LoggerD("Composite post with type: "<<type<<", depth: "<<depth);
 210
 211         if(0<depth) {
 212                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(m_compositeFilters[depth-1], m_compositeFilters[depth])) LoggerW("Filter add failed.");
 213                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(m_normalInstanceCompositeFilters[depth-1], m_normalInstanceCompositeFilters[depth])) LoggerW("Filter add failed.");
 214                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(m_alldayInstanceCompositeFilters[depth-1], m_alldayInstanceCompositeFilters[depth])) LoggerW("Filter add failed.");
 215         } else {
 216                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(m_filter, m_compositeFilters[depth])) LoggerW("Filter add failed.");
 217                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(m_normalInstanceFilter, m_normalInstanceCompositeFilters[depth])) LoggerW("Filter add failed.");
 218                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(m_alldayInstanceFilter, m_alldayInstanceCompositeFilters[depth])) LoggerW("Filter add failed.");
 219         }
 220
 221         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(m_compositeFilters[depth])) LoggerW("Filter destroy failed.");
 222         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(m_normalInstanceCompositeFilters[depth])) LoggerW("Filter destroy failed.");
 223         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(m_alldayInstanceCompositeFilters[depth])) LoggerW("Filter destroy failed.");
 224
 225         m_compositeFilters.pop_back();
 226         m_normalInstanceCompositeFilters.pop_back();
 227         m_alldayInstanceCompositeFilters.pop_back();
 228 }
 229
 230 void CalendarFilter::visitAttribute(std::string& attrName, DeviceAPI::Tizen::MatchFlag& matchFlag, DeviceAPI::Tizen::AnyPtr& matchValue, int depth)
 231 {
 232         if(NULL==matchValue) {
 233         LoggerW("Empty match value.");
 234                 return;
 235         }
 236
 237         LoggerI("attrName: "<<attrName<<", value string: "<<matchValue->toString()<<", matchFlag: "<<matchFlag<<", depth:"<<depth);
 238
 239     calendar_match_str_flag_e strMatchFlag = CALENDAR_MATCH_EXACTLY;
 240     calendar_match_int_flag_e intMatchFlag = CALENDAR_MATCH_EQUAL;
 241
 242         if( DeviceAPI::Tizen::MATCH_EXACTLY==matchFlag ) {
 243                 strMatchFlag = CALENDAR_MATCH_EXACTLY;
 244         intMatchFlag = CALENDAR_MATCH_EQUAL;
 245         } else if( DeviceAPI::Tizen::MATCH_FULLSTRING==matchFlag ) {
 246         strMatchFlag = CALENDAR_MATCH_FULLSTRING;
 247         } else if( DeviceAPI::Tizen::MATCH_CONTAINS==matchFlag) {
 248         strMatchFlag = CALENDAR_MATCH_CONTAINS;
 249         } else if( DeviceAPI::Tizen::MATCH_STARTSWITH==matchFlag) {
 250         strMatchFlag = CALENDAR_MATCH_STARTSWITH;
 251         } else if( DeviceAPI::Tizen::MATCH_ENDSWITH==matchFlag) {
 252         strMatchFlag = CALENDAR_MATCH_ENDSWITH;
 253         }else if( DeviceAPI::Tizen::MATCH_EXISTS==matchFlag) {
 254         strMatchFlag = CALENDAR_MATCH_EXISTS;
 255         } else {
 256                 LoggerW("Invalid matchFlag!");
 257         }
 258
 259         calendar_filter_h currentFilter = NULL;
 260         calendar_filter_h currentNormalInstanceFilter = NULL;
 261         calendar_filter_h currentAlldayInstanceFilter = NULL;
 262         if(0<depth) {
 263                 currentFilter = m_compositeFilters[depth-1];
 264                 currentNormalInstanceFilter = m_normalInstanceCompositeFilters[depth-1];
 265                 currentAlldayInstanceFilter = m_alldayInstanceCompositeFilters[depth-1];
 266         } else {
 267                 currentFilter = m_filter;
 268                 currentNormalInstanceFilter = m_normalInstanceFilter;
 269                 currentAlldayInstanceFilter = m_alldayInstanceFilter;
 270         }
 271
 272     if(CALENDAR_FILTER_ATTRIBUTE_VISIBILITY==attrName ||
 273         CALENDAR_FILTER_ATTRIBUTE_STATUS==attrName ||
 274         CALENDAR_FILTER_ATTRIBUTE_PRIORITY==attrName ||
 275         CALENDAR_FILTER_ATTRIBUTE_PROGRESS==attrName ||
 276         CALENDAR_FILTER_ATTRIBUTE_AVAILABILITY==attrName) {
 277         int value;
 278         if(CALENDAR_FILTER_ATTRIBUTE_VISIBILITY==attrName
 279             || CALENDAR_FILTER_ATTRIBUTE_STATUS==attrName
 280             || CALENDAR_FILTER_ATTRIBUTE_PRIORITY==attrName
 281             || CALENDAR_FILTER_ATTRIBUTE_AVAILABILITY==attrName) {
 282             value = convertStringToIntValue(attrName, matchValue->getString());
 283         } else {
 284             value = matchValue->getLong();
 285         }
 286
 287         if(CalendarEvent::TASK_TYPE==m_type) {
 288             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_taskAttributeMap[attrName], intMatchFlag, value)) LoggerW("Filter add failed.");
 289         } else {
 290             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_eventAttributeMap[attrName], intMatchFlag, value)) LoggerW("Filter add failed.");
 291             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], intMatchFlag, value)) LoggerW("Filter add failed.");
 292             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], intMatchFlag, value)) LoggerW("Filter add failed.");
 293         }
 294         LoggerD("Added int filter with value: "<<value);
 295     } else if(CALENDAR_FILTER_ATTRIBUTE_ID_UID==attrName ||
 296         CALENDAR_FILTER_ATTRIBUTE_ID==attrName) {
 297         int id;
 298         std::stringstream ss(matchValue->getString());
 299         ss>>id;
 300
 301         if(CalendarEvent::TASK_TYPE==m_type) {
 302             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_taskAttributeMap[attrName], intMatchFlag, id)) LoggerW("Filter add failed.");
 303         } else {
 304             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_eventAttributeMap[attrName], intMatchFlag, id)) LoggerW("Filter add failed.");
 305             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], intMatchFlag, id)) LoggerW("Filter add failed.");
 306             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], intMatchFlag, id)) LoggerW("Filter add failed.");
 307
 308             // Include the detached events.
 309             if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentFilter, CALENDAR_FILTER_OPERATOR_OR)) LoggerW("Filter add failed.");
 310             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, _calendar_event.original_event_id, CALENDAR_MATCH_EQUAL, id)) LoggerW("Filter add failed.");
 311             if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentNormalInstanceFilter, CALENDAR_FILTER_OPERATOR_OR)) LoggerW("Filter add failed.");
 312             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, _calendar_instance_normal_calendar_book.original_event_id, CALENDAR_MATCH_EQUAL, id)) LoggerW("Filter add failed.");
 313             if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentAlldayInstanceFilter, CALENDAR_FILTER_OPERATOR_OR)) LoggerW("Filter add failed.");
 314             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, _calendar_instance_allday_calendar_book.original_event_id, CALENDAR_MATCH_EQUAL, id)) LoggerW("Filter add failed.");
 315         }
 316         LoggerD("Added int filter with id: "<<id);
 317     } else if(CALENDAR_FILTER_ATTRIBUTE_LAST_MODIFIED_DATE==attrName ||
 318         CALENDAR_FILTER_ATTRIBUTE_COMPLETED_DATE==attrName) {
 319                 long long int time = getTimeTFromTZDateAny(matchValue);
 320         if(CalendarEvent::TASK_TYPE==m_type) {
 321             if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentFilter, m_taskAttributeMap[attrName], intMatchFlag, time)) LoggerW("Filter add failed.");
 322         } else {
 323             if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentFilter, m_eventAttributeMap[attrName], intMatchFlag, time)) LoggerW("Filter add failed.");
 324             if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], intMatchFlag, time)) LoggerW("Filter add failed.");
 325             if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], intMatchFlag, time)) LoggerW("Filter add failed.");
 326         }
 327         LoggerD("Added lli filter with value: "<<time);
 328     } else if(CALENDAR_FILTER_ATTRIBUTE_DESCRIPTION==attrName ||
 329         CALENDAR_FILTER_ATTRIBUTE_SUMMARY==attrName ||
 330         CALENDAR_FILTER_ATTRIBUTE_LOCATION==attrName ||
 331         CALENDAR_FILTER_ATTRIBUTE_ORGANIZER==attrName) {
 332         if(CalendarEvent::TASK_TYPE==m_type) {
 333             if(CALENDAR_ERROR_NONE!=calendar_filter_add_str(currentFilter, m_taskAttributeMap[attrName], strMatchFlag, matchValue->getString().c_str())) LoggerW("Filter add failed.");
 334         } else {
 335             if(CALENDAR_ERROR_NONE!=calendar_filter_add_str(currentFilter, m_eventAttributeMap[attrName], strMatchFlag, matchValue->getString().c_str())) LoggerW("Filter add failed.");
 336             if(CALENDAR_ERROR_NONE!=calendar_filter_add_str(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], strMatchFlag, matchValue->getString().c_str())) LoggerW("Filter add failed.");
 337                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_str(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], strMatchFlag, matchValue->getString().c_str())) LoggerW("Filter add failed.");
 338         }
 339         LoggerD("Added str filter with value: "<<matchValue->getString());
 340     } else if(CALENDAR_FILTER_ATTRIBUTE_IS_ALL_DAY==attrName) {
 341         if(CalendarEvent::TASK_TYPE==m_type) {
 342             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_EQUAL, matchValue->getBool() ? 1 : 0)) LoggerW("Filter add failed.");
 343         } else {
 344             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_EQUAL, matchValue->getBool() ? 1 : 0)) LoggerW("Filter add failed.");
 345                         if(matchValue->getBool()) {
 346                                 // Exclude the normal instance table.
 347                     if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, m_normalInstanceAttributeMap[CALENDAR_FILTER_ATTRIBUTE_ID_UID], CALENDAR_MATCH_EQUAL, -999)) LoggerW("Filter add failed.");
 348                         } else {
 349                                 // Exclude the allday instance table.
 350                     if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[CALENDAR_FILTER_ATTRIBUTE_ID_UID], CALENDAR_MATCH_EQUAL, -999)) LoggerW("Filter add failed.");
 351                         }
 352         }
 353         LoggerD("Added int filter with value: "<<matchValue->getBool());
 354     } else if(CALENDAR_FILTER_ATTRIBUTE_START_DATE==attrName ||
 355         CALENDAR_FILTER_ATTRIBUTE_DUE_DATE==attrName ||
 356         CALENDAR_FILTER_ATTRIBUTE_END_DATE==attrName) {
 357         calendar_time_s calTime = {CALENDAR_TIME_UTIME, {0}};
 358         long long int time = getTimeTFromTZDateAny(matchValue);
 359         calTime.time.utime = time;
 360         if(CalendarEvent::TASK_TYPE==m_type) {
 361             if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(currentFilter, m_taskAttributeMap[attrName], intMatchFlag, calTime)) LoggerW("Filter add failed.");
 362         } else {
 363             if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(currentFilter, m_eventAttributeMap[attrName], intMatchFlag, calTime)) LoggerW("Filter add failed.");
 364             if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], intMatchFlag, calTime)) LoggerW("Filter add failed.");
 365             if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], intMatchFlag, calTime)) LoggerW("Filter add failed.");
 366         }
 367         LoggerD("Added caltime filter with value: "<<time);
 368     } else if(CALENDAR_FILTER_ATTRIBUTE_LATITUDE==attrName ||
 369         CALENDAR_FILTER_ATTRIBUTE_LONGITUDE==attrName) {
 370         if(CalendarEvent::TASK_TYPE==m_type) {
 371             if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentFilter, m_taskAttributeMap[attrName], intMatchFlag, matchValue->getDouble())) LoggerW("Filter add failed.");
 372         } else {
 373             if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentFilter, m_eventAttributeMap[attrName], intMatchFlag, matchValue->getDouble())) LoggerW("Filter add failed.");
 374             if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], intMatchFlag, matchValue->getDouble())) LoggerW("Filter add failed.");
 375             if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], intMatchFlag, matchValue->getDouble())) LoggerW("Filter add failed.");
 376         }
 377         LoggerD("Added double filter with value: "<<matchValue->getDouble());
 378     } else if(CALENDAR_FILTER_ATTRIBUTE_ALARMS==attrName ||
 379         CALENDAR_FILTER_ATTRIBUTE_ATTENDEES==attrName) {
 380         if(CalendarEvent::TASK_TYPE==m_type) {
 381                         if( DeviceAPI::Tizen::MATCH_EXACTLY==matchFlag ) {
 382                                 if( matchValue->isNullOrUndefined() ) {
 383                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 0)) LoggerW("Filter add failed.");
 384                                 } else {
 385                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 1)) LoggerW("Filter add failed.");
 386                                 }
 387                         } else {
 388                     if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 1)) LoggerW("Filter add failed.");
 389                         }
 390         } else {
 391                         if( DeviceAPI::Tizen::MATCH_EXACTLY==matchFlag ) {
 392                                 if( matchValue->isNullOrUndefined() ) {
 393                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 0)) LoggerW("Filter add failed.");
 394                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 0)) LoggerW("Filter add failed.");
 395                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 0)) LoggerW("Filter add failed.");
 396                         } else {
 397                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 1)) LoggerW("Filter add failed.");
 398                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 1)) LoggerW("Filter add failed.");
 399                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 1)) LoggerW("Filter add failed.");
 400
 401                         }
 402                         } else {
 403                     if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 1)) LoggerW("Filter add failed.");
 404                     if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 1)) LoggerW("Filter add failed.");
 405                     if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 1)) LoggerW("Filter add failed.");
 406                         }
 407         }
 408         LoggerD("Added int filter.");
 409     } else if(CALENDAR_FILTER_ATTRIBUTE_CATEGORIES==attrName) {
 410         if(CalendarEvent::TASK_TYPE==m_type) {
 411             if(CALENDAR_ERROR_NONE!=calendar_filter_add_str(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_CONTAINS, matchValue->getString().c_str())) LoggerW("Filter add failed.");
 412         } else {
 413             if(CALENDAR_ERROR_NONE!=calendar_filter_add_str(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_CONTAINS, matchValue->getString().c_str())) LoggerW("Filter add failed.");
 414             if(CALENDAR_ERROR_NONE!=calendar_filter_add_str(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_CONTAINS, matchValue->getString().c_str())) LoggerW("Filter add failed.");
 415             if(CALENDAR_ERROR_NONE!=calendar_filter_add_str(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_CONTAINS, matchValue->getString().c_str())) LoggerW("Filter add failed.");
 416         }
 417         LoggerD("Added str filter for categories with value: "<<matchValue->getString());
 418     } else if(CALENDAR_FILTER_ATTRIBUTE_IS_DETACHED==attrName) {
 419         if(CalendarEvent::TASK_TYPE==m_type) {
 420             LoggerW("isDetached not supported for a task.");
 421         } else {
 422             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN, 0)) LoggerW("Filter add failed.");
 423             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN, 0)) LoggerW("Filter add failed.");
 424             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN, 0)) LoggerW("Filter add failed.");
 425         }
 426         LoggerD("Added int filter for isDetached with value 0.");
 427     } else if(CALENDAR_FILTER_ATTRIBUTE_RECURRENCE_RULE==attrName) {
 428         if(CalendarEvent::TASK_TYPE==m_type) {
 429             LoggerW("rrule not supported for a task.");
 430         } else {
 431                         if( DeviceAPI::Tizen::MATCH_EXACTLY==matchFlag ) {
 432                                 if( matchValue->isNullOrUndefined() ) {
 433                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 0)) LoggerW("Filter add failed.");
 434                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 0)) LoggerW("Filter add failed.");
 435                             if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_EQUAL, 0)) LoggerW("Filter add failed.");
 436                                 } else {
 437                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN, 0)) LoggerW("Filter add failed.");
 438                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN, 0)) LoggerW("Filter add failed.");
 439                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN, 0)) LoggerW("Filter add failed.");
 440                         }
 441                         LoggerD("Added int filter for rrule EXACTLY flag.");
 442                         } else {
 443                     if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN, 0)) LoggerW("Filter add failed.");
 444                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN, 0)) LoggerW("Filter add failed.");
 445                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN, 0)) LoggerW("Filter add failed.");
 446                         LoggerD("Added int filter for rrule.");
 447                         }
 448         }
 449     } else {
 450         LoggerW("Not supported filter attribute: "<<attrName);
 451     }
 452
 453         LoggerD("Attribute visit done.");
 454 }
 455
 456 void CalendarFilter::visitAttributeRange(std::string& attrName, DeviceAPI::Tizen::AnyPtr& initialValue, DeviceAPI::Tizen::AnyPtr& endValue, int depth)
 457 {
 458         if(initialValue == NULL && endValue == NULL) {
 459         LoggerW("Both initial/end values are empty.");
 460                 return;
 461         }
 462
 463     LoggerI("attrName: " <<attrName<<", initialValue: "<<initialValue->toString()<<", endValue: " <<endValue->toString()<<", depth: "<<depth);
 464
 465         calendar_filter_h currentFilter = NULL;
 466         calendar_filter_h currentNormalInstanceFilter = NULL;
 467         calendar_filter_h currentAlldayInstanceFilter = NULL;
 468         if(0<depth) {
 469                 currentFilter = m_compositeFilters[depth-1];
 470                 currentNormalInstanceFilter = m_normalInstanceCompositeFilters[depth-1];
 471                 currentAlldayInstanceFilter = m_alldayInstanceCompositeFilters[depth-1];
 472         } else {
 473                 currentFilter = m_filter;
 474                 currentNormalInstanceFilter = m_normalInstanceFilter;
 475                 currentAlldayInstanceFilter = m_alldayInstanceFilter;
 476         }
 477
 478     if(CALENDAR_FILTER_ATTRIBUTE_START_DATE==attrName ||
 479         CALENDAR_FILTER_ATTRIBUTE_DUE_DATE==attrName ||
 480         CALENDAR_FILTER_ATTRIBUTE_END_DATE==attrName) {
 481         calendar_time_s startTime = {CALENDAR_TIME_UTIME, {0}};
 482         calendar_time_s endTime = {CALENDAR_TIME_UTIME, {0}};
 483         calendar_time_s startTimeAllday = {CALENDAR_TIME_LOCALTIME, {0}};
 484         calendar_time_s endTimeAllday = {CALENDAR_TIME_LOCALTIME, {0}};
 485         if (!initialValue->isNullOrUndefined()) {
 486             startTime.time.utime = getTimeTFromTZDateAny(initialValue);
 487                         startTimeAllday.time.date = CalendarUtility::LLIToCalTime(NULL, getTimeTFromTZDateAny(initialValue)).time.date;
 488         }
 489         if (!endValue->isNullOrUndefined()) {
 490             endTime.time.utime = getTimeTFromTZDateAny(endValue);
 491                         endTimeAllday.time.date = CalendarUtility::LLIToCalTime(NULL, getTimeTFromTZDateAny(endValue)).time.date;
 492         }
 493         if(CalendarEvent::TASK_TYPE==m_type) {
 494                         calendar_filter_h subFilter = NULL;
 495                 if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_todo._uri, &subFilter)) LoggerW("Filter creation failed.");
 496
 497                         calendar_filter_h subFilter2 = NULL;
 498                 if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_todo._uri, &subFilter2)) LoggerW("Filter creation failed.");
 499             if (!initialValue->isNullOrUndefined()) {
 500                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilter2, m_taskAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, startTime)) LoggerW("Filter add failed.");
 501             }
 502             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 503                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(subFilter2, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 504             }
 505             if (!endValue->isNullOrUndefined()) {
 506                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilter2, m_taskAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endTime)) LoggerW("Filter add failed.");
 507             }
 508                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(subFilter, subFilter2)) LoggerW("Filter add failed.");
 509                         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(subFilter2)) LoggerW("Filter destroy failed.");
 510
 511                         calendar_filter_h subFilter3 = NULL;
 512                 if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_todo._uri, &subFilter3)) LoggerW("Filter creation failed.");
 513             if (!initialValue->isNullOrUndefined()) {
 514                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilter3, m_taskAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, startTimeAllday)) LoggerW("Filter add failed.");
 515             }
 516             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 517                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(subFilter3, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 518             }
 519             if (!endValue->isNullOrUndefined()) {
 520                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilter3, m_taskAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endTimeAllday)) LoggerW("Filter add failed.");
 521             }
 522                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(subFilter, CALENDAR_FILTER_OPERATOR_OR)) LoggerW("Filter add failed.");
 523                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(subFilter, subFilter3)) LoggerW("Filter add failed.");
 524                         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(subFilter3)) LoggerW("Filter destroy failed.");
 525
 526                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(currentFilter, subFilter)) LoggerW("Filter add failed.");
 527                         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(subFilter)) LoggerW("Filter destroy failed.");
 528         } else {
 529                         calendar_filter_h subFilter = NULL;
 530                         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_event._uri, &subFilter)) LoggerW("Filter creation failed.");
 531
 532                         calendar_filter_h subFilter2 = NULL;
 533                         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_event._uri, &subFilter2)) LoggerW("Filter creation failed.");
 534             if (!initialValue->isNullOrUndefined()) {
 535                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilter2, m_eventAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, startTime)) LoggerW("Filter add failed.");
 536             }
 537             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 538                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(subFilter2, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 539             }
 540             if (!endValue->isNullOrUndefined()) {
 541                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilter2, m_eventAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endTime)) LoggerW("Filter add failed.");
 542             }
 543                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(subFilter, subFilter2)) LoggerW("Filter add failed.");
 544                         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(subFilter2)) LoggerW("Filter destroy failed.");
 545
 546                         calendar_filter_h subFilter3 = NULL;
 547                 if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_event._uri, &subFilter3)) LoggerW("Filter creation failed.");
 548             if (!initialValue->isNullOrUndefined()) {
 549                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilter3, m_eventAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, startTimeAllday)) LoggerW("Filter add failed.");
 550             }
 551             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 552                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(subFilter3, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 553             }
 554             if (!endValue->isNullOrUndefined()) {
 555                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilter3, m_eventAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endTimeAllday)) LoggerW("Filter add failed.");
 556             }
 557                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(subFilter, CALENDAR_FILTER_OPERATOR_OR)) LoggerW("Filter add failed.");
 558                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(subFilter, subFilter3)) LoggerW("Filter add failed.");
 559                         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(subFilter3)) LoggerW("Filter destroy failed.");
 560
 561                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(currentFilter, subFilter)) LoggerW("Filter add failed.");
 562                         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(subFilter)) LoggerW("Filter destroy failed.");
 563
 564                         LoggerD("Query for normal instances.");
 565                         calendar_filter_h subFilterNormal = NULL;
 566                         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_instance_normal_calendar_book._uri, &subFilterNormal)) LoggerW("Filter creation failed.");
 567
 568             if (!initialValue->isNullOrUndefined()) {
 569                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilterNormal, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, startTime)) LoggerW("Filter add failed.");
 570             }
 571             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 572                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(subFilterNormal, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 573             }
 574             if (!endValue->isNullOrUndefined()) {
 575                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilterNormal, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endTime)) LoggerW("Filter add failed.");
 576             }
 577                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(currentNormalInstanceFilter, subFilterNormal)) LoggerW("Filter add failed.");
 578                         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(subFilterNormal)) LoggerW("Filter destroy failed.");
 579
 580                         LoggerD("Query for allday instances.");
 581                         calendar_filter_h subFilterAllday = NULL;
 582                         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_instance_allday_calendar_book._uri, &subFilterAllday)) LoggerW("Filter creation failed.");
 583
 584             if (!initialValue->isNullOrUndefined()) {
 585                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilterAllday, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, startTimeAllday)) LoggerW("Filter add failed.");
 586             }
 587             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 588                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(subFilterAllday, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 589             }
 590             if (!endValue->isNullOrUndefined()) {
 591                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_caltime(subFilterAllday, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endTimeAllday)) LoggerW("Filter add failed.");
 592             }
 593                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(currentAlldayInstanceFilter, subFilterAllday)) LoggerW("Filter add failed.");
 594                         if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(subFilterAllday)) LoggerW("Filter destroy failed.");
 595
 596                         LoggerD("Enable the instance table search.");
 597                         m_enableInstanceSearch = true;
 598         }
 599         LoggerD("Added caltime range filter with initial value: "<<startTime.time.utime<<", end value: "<<endTime.time.utime);
 600     } else if(CALENDAR_FILTER_ATTRIBUTE_LATITUDE==attrName ||
 601         CALENDAR_FILTER_ATTRIBUTE_LONGITUDE==attrName) {
 602         if(CalendarEvent::TASK_TYPE==m_type) {
 603             if (!initialValue->isNullOrUndefined()) {
 604                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, initialValue->getDouble())) LoggerW("Filter add failed.");
 605             }
 606             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 607                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 608             }
 609             if (!endValue->isNullOrUndefined()) {
 610                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endValue->getDouble())) LoggerW("Filter add failed.");
 611             }
 612         } else {
 613             if (!initialValue->isNullOrUndefined()) {
 614                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, initialValue->getDouble())) LoggerW("Filter add failed.");
 615                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, initialValue->getDouble())) LoggerW("Filter add failed.");
 616                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, initialValue->getDouble())) LoggerW("Filter add failed.");
 617             }
 618             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 619                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 620                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentNormalInstanceFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 621                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentAlldayInstanceFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 622             }
 623             if (!endValue->isNullOrUndefined()) {
 624                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endValue->getDouble())) LoggerW("Filter add failed.");
 625                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endValue->getDouble())) LoggerW("Filter add failed.");
 626                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_double(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endValue->getDouble())) LoggerW("Filter add failed.");
 627             }
 628         }
 629         LoggerD("Added double range filter with initial value: "<<initialValue->getDouble()<<", end value: "<<endValue->getDouble());
 630     } else if(CALENDAR_FILTER_ATTRIBUTE_COMPLETED_DATE==attrName ||
 631         CALENDAR_FILTER_ATTRIBUTE_LAST_MODIFIED_DATE==attrName) {
 632         if(CalendarEvent::TASK_TYPE==m_type) {
 633             if (!initialValue->isNullOrUndefined()) {
 634                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, getTimeTFromTZDateAny(initialValue))) LoggerW("Filter add failed.");
 635             }
 636             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 637                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 638             }
 639             if (!endValue->isNullOrUndefined()) {
 640                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, getTimeTFromTZDateAny(endValue))) LoggerW("Filter add failed.");
 641             }
 642         } else {
 643             if (!initialValue->isNullOrUndefined()) {
 644                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, getTimeTFromTZDateAny(initialValue))) LoggerW("Filter add failed.");
 645                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, getTimeTFromTZDateAny(initialValue))) LoggerW("Filter add failed.");
 646                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, getTimeTFromTZDateAny(initialValue))) LoggerW("Filter add failed.");
 647             }
 648             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 649                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 650                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentNormalInstanceFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 651                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentAlldayInstanceFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 652             }
 653             if (!endValue->isNullOrUndefined()) {
 654                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentFilter, m_eventAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, getTimeTFromTZDateAny(endValue))) LoggerW("Filter add failed.");
 655                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentNormalInstanceFilter, m_normalInstanceAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, getTimeTFromTZDateAny(endValue))) LoggerW("Filter add failed.");
 656                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_lli(currentAlldayInstanceFilter, m_alldayInstanceAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, getTimeTFromTZDateAny(endValue))) LoggerW("Filter add failed.");
 657             }
 658         }
 659         LoggerD("Added lli range filter with initial value: "<<getTimeTFromTZDateAny(initialValue)<<", end value: "<<getTimeTFromTZDateAny(endValue));
 660     } else if(CALENDAR_FILTER_ATTRIBUTE_PROGRESS==attrName) {
 661         if(CalendarEvent::TASK_TYPE==m_type) {
 662             if (!initialValue->isNullOrUndefined()) {
 663                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_GREATER_THAN_OR_EQUAL, initialValue->getLong())) LoggerW("Filter add failed.");
 664             }
 665             if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 666                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(currentFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 667             }
 668             if (!endValue->isNullOrUndefined()) {
 669                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(currentFilter, m_taskAttributeMap[attrName], CALENDAR_MATCH_LESS_THAN_OR_EQUAL, endValue->getLong())) LoggerW("Filter add failed.");
 670             }
 671         } else {
 672                         LoggerW("progress not supported for an event");
 673         }
 674         LoggerD("Added double range filter with initial value: "<<initialValue->getLong()<<", end value: "<<endValue->getLong());
 675     } else {
 676         LoggerW("Not supported filter attribute: "<<attrName);
 677     }
 678
 679     LoggerD("Attribute range visit done.");
 680 }
 681
 682 void CalendarFilter::setType(CalendarEvent::CalendarType type)
 683 {
 684     if(CalendarEvent::TASK_TYPE==type) {
 685         m_type = CalendarEvent::TASK_TYPE;
 686         calendar_query_create(_calendar_todo._uri, &m_query);
 687         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_todo._uri, &m_filter)) LoggerW("Filter creation failed.");
 688     } else {
 689         m_type = CalendarEvent::EVENT_TYPE;
 690         calendar_query_create(_calendar_event._uri, &m_query);
 691         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_event._uri, &m_filter)) LoggerW("Filter creation failed.");
 692
 693         calendar_query_create(_calendar_instance_normal_calendar_book._uri, &m_normalInstanceQuery);
 694         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_instance_normal_calendar_book._uri, &m_normalInstanceFilter)) LoggerW("Filter creation failed.");
 695         calendar_query_create(_calendar_instance_allday_calendar_book._uri, &m_alldayInstanceQuery);
 696         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_instance_allday_calendar_book._uri, &m_alldayInstanceFilter)) LoggerW("Filter creation failed.");
 697     }
 698 }
 699
 700 void CalendarFilter::setCalendarId(int calendarId, bool isFilterSet)
 701 {
 702     if( isFilterSet ) {
 703                 calendar_filter_h m_superFilter = NULL;
 704                 calendar_filter_h m_normalInstanceSuperFilter = NULL;
 705                 calendar_filter_h m_alldayInstanceSuperFilter = NULL;
 706             if(CalendarEvent::TASK_TYPE==m_type) {
 707                         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_todo._uri, &m_superFilter)) LoggerW("Filter creation failed.");
 708                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(m_superFilter, m_filter)) LoggerW("Filter add failed.");
 709                 } else {
 710                         if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_event._uri, &m_superFilter)) LoggerW("Filter creation failed.");
 711                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(m_superFilter, m_filter)) LoggerW("Filter add failed.");
 712                 }
 713                 if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_instance_normal_calendar_book._uri, &m_normalInstanceSuperFilter)) LoggerW("Filter creation failed.");
 714                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(m_normalInstanceSuperFilter, m_normalInstanceFilter)) LoggerW("Filter add failed.");
 715                 if(CALENDAR_ERROR_NONE!=calendar_filter_create(_calendar_instance_allday_calendar_book._uri, &m_alldayInstanceSuperFilter)) LoggerW("Filter creation failed.");
 716                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_filter(m_alldayInstanceSuperFilter, m_alldayInstanceFilter)) LoggerW("Filter add failed.");
 717
 718                 if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(m_filter)) LoggerW("Filter destroy failed.");
 719                 if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(m_normalInstanceFilter)) LoggerW("Filter add failed.");
 720                 if(CALENDAR_ERROR_NONE!=calendar_filter_destroy(m_alldayInstanceFilter)) LoggerW("Filter add failed.");
 721
 722                 m_filter = m_superFilter;
 723                 m_normalInstanceFilter= m_normalInstanceSuperFilter;
 724                 m_alldayInstanceFilter = m_alldayInstanceSuperFilter;
 725                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_filter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 726                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_normalInstanceFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 727                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_alldayInstanceFilter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 728     }
 729
 730     if(CalendarEvent::TASK_TYPE==m_type) {
 731                 if(CALENDAR_BOOK_FILTER_ALL==calendarId) {
 732                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(m_filter, _calendar_todo.calendar_book_id, CALENDAR_MATCH_GREATER_THAN, calendarId)) LoggerW("Filter add failed.");
 733                 } else {
 734                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(m_filter, _calendar_todo.calendar_book_id, CALENDAR_MATCH_EQUAL, calendarId)) LoggerW("Filter add failed.");
 735                 }
 736
 737         if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_filter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 738         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(m_filter, _calendar_todo.is_deleted, CALENDAR_MATCH_EQUAL, 0)) LoggerW("Filter add failed.");
 739     } else {
 740                 if(CALENDAR_BOOK_FILTER_ALL==calendarId) {
 741                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(m_filter, _calendar_event.calendar_book_id, CALENDAR_MATCH_GREATER_THAN, calendarId)) LoggerW("Filter add failed.");
 742                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(m_normalInstanceFilter, _calendar_instance_normal_calendar_book.calendar_book_id, CALENDAR_MATCH_GREATER_THAN, calendarId)) LoggerW("Filter add failed.");
 743                         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(m_alldayInstanceFilter, _calendar_instance_allday_calendar_book.calendar_book_id, CALENDAR_MATCH_GREATER_THAN, calendarId)) LoggerW("Filter add failed.");
 744                 } else {
 745                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(m_filter, _calendar_event.calendar_book_id, CALENDAR_MATCH_EQUAL, calendarId)) LoggerW("Filter add failed.");
 746                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(m_normalInstanceFilter, _calendar_instance_normal_calendar_book.calendar_book_id, CALENDAR_MATCH_EQUAL, calendarId)) LoggerW("Filter add failed.");
 747                 if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(m_alldayInstanceFilter, _calendar_instance_allday_calendar_book.calendar_book_id, CALENDAR_MATCH_EQUAL, calendarId)) LoggerW("Filter add failed.");
 748                 }
 749
 750                 /* No matching is_deleted field for instance tables. */
 751         if(CALENDAR_ERROR_NONE!=calendar_filter_add_operator(m_filter, CALENDAR_FILTER_OPERATOR_AND)) LoggerW("Filter add failed.");
 752         if(CALENDAR_ERROR_NONE!=calendar_filter_add_int(m_filter, _calendar_event.is_deleted, CALENDAR_MATCH_EQUAL, 0)) LoggerW("Filter add failed.");
 753     }
 754 }
 755
 756 void CalendarFilter::setSortMode(DeviceAPI::Tizen::SortModeArrayPtr attr)
 757 {
 758         std::string attrName;
 759         DeviceAPI::Tizen::SortModeArray::iterator it = attr->begin();
 760
 761     // The first sort mode only.
 762         attrName = (*it)->getAttributeName();
 763         if (attrName.compare("") != 0) {
 764         LoggerD("Setting the sort mode with attrName: "<<attrName);
 765                 if ((*it)->getOrder()==DeviceAPI::Tizen::ASCENDING_SORT_ORDER) {
 766             if(CalendarEvent::TASK_TYPE==m_type) {
 767                         calendar_query_set_sort(m_query, m_taskAttributeMap[attrName], true);
 768             } else {
 769                         calendar_query_set_sort(m_query, m_eventAttributeMap[attrName], true);
 770                         calendar_query_set_sort(m_normalInstanceQuery, m_normalInstanceAttributeMap[attrName], true);
 771                         calendar_query_set_sort(m_alldayInstanceQuery, m_alldayInstanceAttributeMap[attrName], true);
 772             }
 773                 } else {
 774             if(CalendarEvent::TASK_TYPE==m_type) {
 775                         calendar_query_set_sort(m_query, m_taskAttributeMap[attrName], false);
 776             } else {
 777                         calendar_query_set_sort(m_query, m_eventAttributeMap[attrName], false);
 778                         calendar_query_set_sort(m_normalInstanceQuery, m_normalInstanceAttributeMap[attrName], false);
 779                         calendar_query_set_sort(m_alldayInstanceQuery, m_alldayInstanceAttributeMap[attrName], false);
 780             }
 781                 }
 782         } else {
 783             LoggerW("Empty attribute name.");
 784         }
 785 }
 786
 787 void CalendarFilter::executeQuery()
 788 {
 789     int ret;
 790     ret = calendar_query_set_filter(m_query, m_filter);
 791     if( CALENDAR_ERROR_NONE!=ret ) {
 792         ThrowMsg(PlatformException, "Setting filter failed: "<<ret);
 793     }
 794
 795         ret = calendar_db_get_records_with_query(m_query, 0, 0, &m_recordList);
 796     if( CALENDAR_ERROR_NONE!=ret ) {
 797         ThrowMsg(PlatformException, "Getting record list failed: "<<ret);
 798     }
 799
 800     ret = calendar_list_get_count(m_recordList, &m_recordCount);
 801     if( CALENDAR_ERROR_NONE!=ret ) {
 802         ThrowMsg(PlatformException, "Can't get the item count: "<<ret);
 803     } else {
 804         LoggerD("Item count: "<<m_recordCount);
 805     }
 806
 807         if(m_enableInstanceSearch) {
 808                 LoggerD("Perform query for instances.");
 809             ret = calendar_query_set_filter(m_normalInstanceQuery, m_normalInstanceFilter);
 810             if( CALENDAR_ERROR_NONE!=ret ) {
 811                 ThrowMsg(PlatformException, "Setting a normal instance filter failed: "<<ret);
 812             }
 813                 ret = calendar_db_get_records_with_query(m_normalInstanceQuery, 0, 0, &m_normalInstanceRecordList);
 814             if( CALENDAR_ERROR_NONE!=ret ) {
 815                 ThrowMsg(PlatformException, "Getting a normal instance record list failed: "<<ret);
 816             }
 817             ret = calendar_list_get_count(m_normalInstanceRecordList, &m_normalInstanceRecordCount);
 818             if( CALENDAR_ERROR_NONE!=ret ) {
 819                 ThrowMsg(PlatformException, "Can't get a normal instance item count: "<<ret);
 820             } else {
 821                 LoggerD("Normal instance item count: "<<m_normalInstanceRecordCount);
 822             }
 823
 824             ret = calendar_query_set_filter(m_alldayInstanceQuery, m_alldayInstanceFilter);
 825             if( CALENDAR_ERROR_NONE!=ret ) {
 826                 ThrowMsg(PlatformException, "Setting an allday instance filter failed: "<<ret);
 827             }
 828                 ret = calendar_db_get_records_with_query(m_alldayInstanceQuery, 0, 0, &m_alldayInstanceRecordList);
 829             if( CALENDAR_ERROR_NONE!=ret ) {
 830                 ThrowMsg(PlatformException, "Getting an allday instance record list failed: "<<ret);
 831             }
 832             ret = calendar_list_get_count(m_alldayInstanceRecordList, &m_alldayInstanceRecordCount);
 833             if( CALENDAR_ERROR_NONE!=ret ) {
 834                 ThrowMsg(PlatformException, "Can't get an allday instance item count: "<<ret);
 835             } else {
 836                 LoggerD("Allday instance item count: "<<m_alldayInstanceRecordCount);
 837             }
 838         } else {
 839                 LoggerD("No need to perform query for instances.");
 840         }
 841 }
 842
 843 int CalendarFilter::getResultRecordCount() const
 844 {
 845         return m_recordCount;
 846 }
 847
 848 calendar_list_h CalendarFilter::getResultRecordList() const
 849 {
 850         return m_recordList;
 851 }
 852
 853 int CalendarFilter::getNormalInstanceResultRecordCount() const
 854 {
 855         return m_normalInstanceRecordCount;
 856 }
 857
 858 calendar_list_h CalendarFilter::getNormalInstanceResultRecordList() const
 859 {
 860         return m_normalInstanceRecordList;
 861 }
 862
 863 int CalendarFilter::getAlldayInstanceResultRecordCount() const
 864 {
 865         return m_alldayInstanceRecordCount;
 866 }
 867
 868 calendar_list_h CalendarFilter::getAlldayInstanceResultRecordList() const
 869 {
 870         return m_alldayInstanceRecordList;
 871 }
 872
 873 int CalendarFilter::convertStringToIntValue(const std::string attrName, const std::string valueString)
 874 {
 875         LoggerD("attrName: "<<attrName<<", valueString: "<<valueString);
 876
 877     if(attrName==CALENDAR_FILTER_ATTRIBUTE_VISIBILITY)
 878     {
 879         if(valueString=="PUBLIC") {
 880             return CALENDAR_SENSITIVITY_PUBLIC;
 881         } else if(valueString=="PRIVATE") {
 882             return CALENDAR_SENSITIVITY_PRIVATE;
 883         } else if(valueString=="CONFIDENTIAL") {
 884             return CALENDAR_SENSITIVITY_CONFIDENTIAL;
 885         } else {
 886             LoggerW("Wrong visibility value.");
 887         }
 888     }
 889     else if(attrName==CALENDAR_FILTER_ATTRIBUTE_STATUS)
 890     {
 891         if(valueString=="TENTATIVE") {
 892             return CALENDAR_EVENT_STATUS_TENTATIVE;
 893         } else if(valueString=="CONFIRMED") {
 894             return CALENDAR_EVENT_STATUS_CONFIRMED;
 895         } else if(valueString=="CANCELLED") {
 896                         if(CalendarEvent::TASK_TYPE==m_type) {
 897                                 return CALENDAR_TODO_STATUS_CANCELED;
 898                         } else {
 899                                 return CALENDAR_EVENT_STATUS_CANCELLED;
 900                         }
 901         } else if(valueString=="NEEDS_ACTION") {
 902             return CALENDAR_TODO_STATUS_NEEDS_ACTION;
 903         } else if(valueString=="IN_PROCESS") {
 904             return CALENDAR_TODO_STATUS_IN_PROCESS;
 905         } else if(valueString=="COMPLETED") {
 906             return CALENDAR_TODO_STATUS_COMPLETED;
 907         } else {
 908             LoggerW("Wrong status value.");
 909         }
 910     }
 911     else if(attrName==CALENDAR_FILTER_ATTRIBUTE_PRIORITY)
 912     {
 913         if(valueString=="HIGH") {
 914             return CALENDAR_EVENT_PRIORITY_HIGH;
 915         } else if(valueString=="MEDIUM") {
 916             return CALENDAR_EVENT_PRIORITY_NORMAL;
 917         } else if(valueString=="LOW") {
 918             return CALENDAR_EVENT_PRIORITY_LOW;
 919         } else {
 920             LoggerW("Wrong priority value.");
 921         }
 922     }
 923     else if(attrName==CALENDAR_FILTER_ATTRIBUTE_AVAILABILITY)
 924     {
 925         if(valueString=="BUSY") {
 926             return CALENDAR_EVENT_BUSY_STATUS_BUSY;
 927         } else if(valueString=="FREE") {
 928             return CALENDAR_EVENT_BUSY_STATUS_FREE;
 929         } else {
 930             LoggerW("Wrong availability value.");
 931         }
 932     } else {
 933         LoggerW("Invalid attrName");
 934     }
 935
 936     return -1;
 937 }
 938
 939 long long int CalendarFilter::getTimeTFromTZDateAny(DeviceAPI::Tizen::AnyPtr &any) const
 940 {
 941         long long int *pt = static_cast<long long int *>(any->getPriv());
 942
 943         return *pt;
 944 }
 945
 946 }
 947 }