src/Messaging/StorageChangesMessageGenerator.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 "StorageChangesMessageGenerator.h"
  19 #include "StorageChangesMessageFilterValidatorFactory.h"
  20 #include "ConversationFilterValidatorFactory.h"
  21
  22 #include "IMessagingTypes.h"
  23
  24 #include <email-types.h>
  25
  26 #include <algorithm>
  27 #include <Logger.h>
  28
  29 using namespace std;
  30 using namespace DeviceAPI::Tizen;
  31
  32 namespace DeviceAPI {
  33         namespace Messaging {
  34
  35                 const int StorageChangesMessageGenerator::MESSAGE_TYPE_NOT_INITIALIZED = -1;
  36
  37                 StorageChangesMessageGenerator::StorageChangesMessageGenerator(IMessagePtr msg, IConversationPtr conv) :
  38                         m_messageType(MESSAGE_TYPE_NOT_INITIALIZED) , m_serviceId(-1)
  39                         {
  40
  41                         m_id = msg->getIdRef();
  42                         m_type = msg->getMessageType();
  43                         m_folder = msg->getCurrentFolder();
  44                         m_dateTime = msg->getDateTime();
  45                         m_from = msg->getFrom();
  46                         m_conversationId = conv->getConvId();
  47
  48                         Recipents = msg->getToRecipientsPtr();
  49
  50                         if(m_type == SMS)
  51                         {
  52                                 LoggerD("size :" << Recipents->getRecipientSize());
  53
  54                                 if(Recipents->getRecipientSize()>0)
  55                                 {
  56                                 m_to = Recipents->getRecipientsRef();
  57                                         LoggerD("m_to :" << m_to[0]);
  58                                 }
  59                         }
  60                         else if(m_type == MMS)
  61                         {
  62                                 LoggerD("to size :" << Recipents->getRecipientSize());
  63
  64                                 IMmsPtr mms = DPL::DynamicPointerCast<IMms >(msg);
  65                                 if(Recipents->getRecipientSize() > 0)
  66                                 {
  67                                         m_to = Recipents->getRecipientsRef();
  68                                         LoggerD("m_to :" << m_to[0]);
  69                                 }
  70
  71                                 Recipents = mms->getCcRecipientsPtr();
  72                                 LoggerD("cc size :" << Recipents->getRecipientSize());
  73
  74                                 if(Recipents->getRecipientSize() > 0)
  75                                 {
  76                                         m_cc = Recipents->getRecipientsRef();
  77                                 }
  78
  79                                 Recipents = mms->getBccRecipientsPtr();
  80                                 LoggerD("bcc size :" << Recipents->getRecipientSize());
  81
  82                                 if(Recipents->getRecipientSize() > 0)
  83                                 {
  84                                         m_bcc = Recipents->getRecipientsRef();
  85                                 }
  86                                 m_hasAttachment = mms->hasAttachment();
  87
  88
  89                         }
  90                         else if(m_type == EMAIL)
  91                         {
  92                                 LoggerD("to size :" << Recipents->getRecipientSize());
  93
  94                                 IEmailPtr email = DPL::DynamicPointerCast<IEmail >(msg);
  95                                 if(Recipents->getRecipientSize() > 0)
  96                                 {
  97                                         m_to = Recipents->getRecipientsRef();
  98                                         LoggerD("m_to :" << m_to[0]);
  99                                 }
 100
 101                                 Recipents = email->getCcRecipientsPtr();
 102                                 LoggerD("cc size :" << Recipents->getRecipientSize());
 103
 104                                 if(Recipents->getRecipientSize() > 0)
 105                                 {
 106                                         m_cc = Recipents->getRecipientsRef();
 107                                 }
 108
 109                                 Recipents = email->getBccRecipientsPtr();
 110                                 LoggerD("bcc size :" << Recipents->getRecipientSize());
 111
 112                                 if(Recipents->getRecipientSize() > 0)
 113                                 {
 114                                         m_bcc = Recipents->getRecipientsRef();
 115                                 }
 116
 117                                 m_serviceId =  email->getAccountID();
 118                                 if (m_serviceId ==  -1) {
 119                                         ThrowMsg(WrtDeviceApis::Commons::UnknownException,
 120                                         "Couldn't convert e-mail account id");
 121                                 }
 122
 123                                 m_hasAttachment = email->hasAttachment();
 124
 125 //                              if (m_conversationId == email->getUID())
 126 //                                      m_isResponseTo = -1;
 127                                 m_isResponseTo = m_conversationId;
 128
 129                         }
 130
 131
 132
 133                         m_body = msg->getBody();
 134                         m_isRead = msg->isRead();
 135                         m_priority = msg->getPriority();
 136                         m_subject = msg->getSubject();
 137                         m_messageStatus = msg->getMessageStatus();
 138
 139
 140                         LoggerD("m_type:" << m_type );
 141                         LoggerD("m_folder:" << m_folder );
 142                         LoggerD("m_dateTime year:" << m_dateTime.tm_year + 1900 );
 143                         LoggerD("m_dateTime mon:" << m_dateTime.tm_mon );
 144                         LoggerD("m_dateTime day:" << m_dateTime.tm_mday );
 145                         LoggerD("m_dateTime hour:" << m_dateTime.tm_hour );
 146                         LoggerD("m_dateTime min:" << m_dateTime.tm_min );
 147                         LoggerD("m_dateTime sec:" << m_dateTime.tm_sec );
 148                         LoggerD("m_from:" << m_from );
 149                         LoggerD("m_body:" << m_body );
 150                         LoggerD("m_isRead:" << m_isRead );
 151                         LoggerD("m_priority:" << m_priority );
 152                         LoggerD("m_subject:" << m_subject );
 153
 154                 }
 155
 156                 StorageChangesMessageGenerator::~StorageChangesMessageGenerator() {
 157                 }
 158
 159                 void StorageChangesMessageGenerator::visitPreComposite(DeviceAPI::Tizen::FilterType& type, int depth){
 160                         LoggerD("<<<");
 161                         m_operand.push_back(leftblank);
 162                         LoggerD("Left_blank");
 163                         LoggerD(">>>");
 164                 }
 165
 166                 void StorageChangesMessageGenerator::visitInComposite(DeviceAPI::Tizen::FilterType& type, int depth){
 167                         LoggerD("<<<");
 168                         if(type ==  UNION_FILTER ){
 169                                 LoggerD("UNION_FILTER");
 170                                 m_operand.push_back(operandUnion);
 171                         }else if(type == INTERSECTION_FILTER){
 172                                 LoggerD("INTERSECTION_FILTER");
 173                                 m_operand.push_back(operandIntersection);
 174                         }else{
 175                                 LoggerE("[ERROR] invalid Filter type:" << type);
 176                         }
 177
 178                         LoggerD(">>>");
 179                 }
 180
 181                 void StorageChangesMessageGenerator::visitPostComposite(DeviceAPI::Tizen::FilterType& type, int depth){
 182                         LoggerD("<<<");
 183                         bool data1, data2;
 184                         do
 185                         {
 186                                 LoggerD("m_result size =" << m_result.size());
 187                                 data1 = m_result.back();
 188                                 m_result.pop_back();
 189                                 data2 = m_result.back();
 190                                 m_result.pop_back();
 191                                 LoggerD("m_result size =" << m_result.size());
 192                                 LoggerD("m_operand.back() =" << m_operand.back());
 193                                 LoggerD("m_operand size =" << m_operand.size());
 194                                 if(m_operand.back() == operandUnion)
 195                                 {
 196                                         LoggerD("Union");
 197                                         LoggerD("data1 = " << data1);
 198                                         LoggerD("data2 = " << data2);
 199                                         LoggerD("data1 || data2 = " << (data1 || data2));
 200                                         m_operand.pop_back();
 201                                         m_result.push_back(data1 || data2);
 202                                         LoggerD("result" << m_result.back());
 203                                         LoggerD("m_result size =" << m_result.size());
 204                                 }
 205                                 else if(m_operand.back() == operandIntersection)
 206                                 {
 207                                         LoggerD("Intersection");
 208                                         LoggerD("data1 = " << data1);
 209                                         LoggerD("data2 = " << data2);
 210                                         LoggerD("data1 && data2 = " << (data1 && data2));
 211                                         m_operand.pop_back();
 212                                         m_result.push_back(data1 && data2);
 213                                         LoggerD("result" << m_result.back());
 214                                         LoggerD("m_result size =" << m_result.size());
 215
 216                         }
 217                         }while(m_operand.back() != leftblank);
 218                         m_operand.pop_back();
 219                         LoggerD("elase leftblank from m_operand");
 220                         LoggerD("m_operand size =" << m_operand.size());
 221                         LoggerD(">>>");
 222                 }
 223
 224                 struct tm StorageChangesMessageGenerator::convertToTimeFormat(const std::string& timeString){
 225                         LoggerD("<<< timeString:[" << timeString << "]");
 226
 227                         struct tm tm_Time;
 228                         memset(&tm_Time, 0, sizeof(tm_Time));
 229
 230                         int nextStart = 0;
 231
 232                         int yearLength = 4;
 233                         tm_Time.tm_year = atoi(timeString.substr(0, yearLength).c_str())-1900;
 234                         nextStart = nextStart + yearLength;
 235                         LoggerD("<<< tm_Time.tm_year:[" << tm_Time.tm_year << "]");
 236
 237                         int monthLength = 2;
 238                         tm_Time.tm_mon = atoi(timeString.substr(nextStart, monthLength).c_str());
 239                         nextStart = nextStart + monthLength;
 240                         LoggerD("<<< initTime.tm_mon:[" << tm_Time.tm_mon << "]");
 241
 242                         int dateLength = 2;
 243                         tm_Time.tm_mday = atoi(timeString.substr(nextStart, dateLength).c_str());
 244                         nextStart = nextStart + dateLength;
 245                         LoggerD("<<< initTime.tm_mday:[" << tm_Time.tm_mday << "]");
 246
 247                         int hourLength = 2;
 248                         tm_Time.tm_hour = atoi(timeString.substr(nextStart, hourLength).c_str());
 249                         nextStart = nextStart + hourLength;
 250                         LoggerD("<<< initTime.tm_hour:[" << tm_Time.tm_hour << "]");
 251
 252                         int minuteLength = 2;
 253                         tm_Time.tm_min = atoi(timeString.substr(nextStart, minuteLength).c_str());
 254                         nextStart = nextStart + minuteLength;
 255                         LoggerD("<<< initTime.tm_min:[" << tm_Time.tm_min << "]");
 256
 257                         int secondLength = 2;
 258                         tm_Time.tm_sec = atoi(timeString.substr(nextStart, secondLength).c_str());
 259                         LoggerD("<<< initTime.tm_sec:[" << tm_Time.tm_sec << "]");
 260
 261                         return tm_Time;
 262                 }
 263
 264                 bool StorageChangesMessageGenerator::getMatchExactlyClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
 265                 {
 266                         std::string valueString = value->toString();
 267                         LoggerD("<<< attrName : " << attrName);
 268                         LoggerD("<<< valueString : " << valueString);
 269                         LoggerD("<<< attrName.compare(valueString) : " << attrName.compare(valueString));
 270
 271                         if(attrName.compare(valueString) == 0)
 272                         {
 273                                 LoggerD("<<< getMatchExactlyClause SAME >>>");
 274                                 return TRUE;
 275                         }
 276                         else{
 277                                 LoggerD("<<< getMatchExactlyClause DIFF >>>");
 278                                 return FALSE;
 279                         }
 280                         }
 281
 282                 bool StorageChangesMessageGenerator::getMatchFullstringClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
 283                 {
 284                         std::string tempString1;
 285                         std::string tempString2;
 286
 287                         std::string valueString = value->toString();
 288                         LoggerD("<<< attrName : " << attrName);
 289                         LoggerD("<<< valueString : " << valueString);
 290
 291                         tempString1.assign(attrName);
 292                         tempString2.assign(valueString);
 293
 294                         StrLowChange(tempString1);
 295                         StrLowChange(tempString2);
 296
 297                         LoggerD("<<< attrName : " << tempString1);
 298                         LoggerD("<<< valueString : " << tempString2);
 299
 300                         if(tempString1.compare(tempString2) == 0)
 301                         {
 302                                 LoggerD("<<< getMatchFullstringClause SAME >>>");
 303                                 return TRUE;
 304                         }
 305                         else{
 306                                 LoggerD("<<< getMatchFullstringClause DIFF >>>");
 307                                 return FALSE;
 308                         }
 309                 }
 310
 311                 bool StorageChangesMessageGenerator::getMatchContainsClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
 312                 {
 313
 314                         std::string tempString1;
 315                         std::string tempString2;
 316
 317                         std::string valueString = value->toString();
 318                         LoggerD("<<< attrName : " << attrName);
 319                         LoggerD("<<< valueString : " << valueString);
 320
 321                         tempString1.assign(attrName);
 322                         tempString2.assign(valueString);
 323
 324                         StrLowChange(tempString1);
 325                         StrLowChange(tempString2);
 326
 327                         LoggerD("<<< attrName : " << tempString1);
 328                         LoggerD("<<< valueString : " << tempString2);
 329
 330                         if(tempString1.find(tempString2) != std::string::npos)
 331                         {
 332                                 LoggerD("<<< getMatchContainsClause CONTAINS >>>");
 333                                 return TRUE;
 334                         }else{
 335                                 LoggerD("<<< getMatchContainsClause NOT CONTAINS >>>");
 336                                 return FALSE;
 337                         }
 338                 }
 339
 340                 bool StorageChangesMessageGenerator::getMatchStartwithClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
 341                 {
 342                         std::string tempString1;
 343                         std::string tempString2;
 344
 345                         std::string valueString = value->toString();
 346                         LoggerD("<<< attrName : " << attrName);
 347                         LoggerD("<<< valueString : " << valueString);
 348
 349                         tempString1.assign(attrName);
 350                         tempString2.assign(valueString);
 351
 352                         StrLowChange(tempString1);
 353                         StrLowChange(tempString2);
 354
 355                         LoggerD("<<< attrName : " << tempString1);
 356                         LoggerD("<<< valueString : " << tempString2);
 357
 358
 359                         if(tempString1.size() < tempString2.size())
 360                                 return FALSE;
 361
 362                         if(tempString1.compare(0,tempString2.size(), tempString2) == 0)
 363                         {
 364                                 LoggerD("<<< getMatchStartwithClause START WITH >>>");
 365                         return TRUE;
 366                 }
 367                         else{
 368                                 LoggerD("<<< getMatchStartwithClause NOT START WITH >>>");
 369                                 return FALSE;
 370                         }
 371                 }
 372
 373                 bool StorageChangesMessageGenerator::getMatchEndwithClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
 374                 {
 375                         std::string tempString1;
 376                         std::string tempString2;
 377
 378                         std::string valueString = value->toString();
 379
 380                         LoggerD("<<< attrName : " << attrName);
 381                         LoggerD("<<< valueString : " << valueString);
 382
 383                         tempString1.assign(attrName);
 384                         tempString2.assign(valueString);
 385
 386                         StrLowChange(tempString1);
 387                         StrLowChange(tempString2);
 388
 389                         LoggerD("<<< attrName.compare(attrName.size()-valueString.size(),valueString.size(), valueString) : " << attrName.compare(attrName.size()-valueString.size(),valueString.size(), valueString));
 390
 391
 392                         if(tempString1.size() < tempString2.size())
 393                                 return FALSE;
 394
 395                         if(tempString1.compare(tempString1.size()-tempString2.size(),tempString2.size(), tempString2) == 0 )
 396                         {
 397                                 LoggerD("<<< getMatchEndwithClause END WITH >>>");
 398                                 return TRUE;
 399                         }
 400                         else{
 401                                 LoggerD("<<< getMatchEndwithClause NOT END WITH >>>");
 402                                 return FALSE;
 403                         }
 404                 }
 405
 406                 bool StorageChangesMessageGenerator::getBetweenRangeClause(struct tm initialValue, struct tm endValue)
 407                 {
 408                         time_t init_time, mid_time, end_time;
 409                         init_time = mktime(&initialValue);
 410                         mid_time = mktime(&m_dateTime);
 411                         end_time = mktime(&endValue);
 412                         LoggerD("<<< mktime(initialValue):[" << init_time << "]");
 413                         LoggerD("<<< mktime(m_dateTime):[" << mid_time << "]");
 414                         LoggerD("<<< mktime(endValue):[" << end_time << "]");
 415                         LoggerD("<<< mid_time - init_time:[" << mid_time - init_time << "]");
 416                         LoggerD("<<< end_time - mid_time:[" << end_time - mid_time << "]");
 417
 418                         if(((mid_time - init_time) >= 0 ) && ((end_time - mid_time) >= 0 ))
 419                                 return TRUE;
 420                         else
 421                                 return FALSE;
 422
 423                 }
 424
 425                 bool StorageChangesMessageGenerator::getMatchExistClause(std::string& attrName)
 426                 {
 427                         LoggerD("<<< attrName : " << attrName);
 428                         if(attrName.size()> 0)
 429                                 return TRUE;
 430                         else
 431                                 return FALSE;
 432                 }
 433
 434                 void StorageChangesMessageGenerator::visitAttribute(std::string& attrName,
 435                                 MatchFlag& matchFlag, DeviceAPI::Tizen::AnyPtr& matchValue, int depth){
 436                         LoggerD("<<< attrName:[" << attrName << "], matchFlag:[" << matchFlag << "]");
 437                         if(matchFlag != DeviceAPI::Tizen::MATCH_EXISTS){
 438                                 if(matchValue == NULL)  {
 439                                 return;
 440                                 }
 441                         }
 442
 443                         LoggerD("matchValue:" << matchValue->toString());
 444
 445                         visitAttributeEach(attrName, matchFlag, matchValue, depth);
 446
 447                         LoggerD(">>>");
 448                 }
 449
 450                 void StorageChangesMessageGenerator::visitAttributeEach(std::string& attrName, MatchFlag& matchFlag, DeviceAPI::Tizen::AnyPtr& value, int depth){
 451                         LoggerD("<<< attrName:[" << attrName << "], value:[" << value->toString() << "]");
 452                         std::string valueString;
 453
 454 //  Check msg_type and filter_type
 455                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_ID)==0){
 456                                 LoggerD("<<< value:[" << value << "]");
 457                                 LoggerD("<<< value->toString():[" << value->toString() << "]");
 458                                 LoggerD("<<< m_id:[" << m_id << "]");
 459
 460                                 valueString = m_id;
 461                                 if(getMatchFlagResult(value, valueString, matchFlag))
 462                                 {
 463                                         m_result.push_back(TRUE);
 464                                         LoggerD("<<< id is same");
 465                                 }
 466                                 else
 467                                 {
 468                                         m_result.push_back(FALSE);
 469                                         LoggerD("<<< id is different");
 470                                 }
 471                                 return;
 472                         }
 473
 474                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_SERVICE_ID)==0){
 475                                 LoggerD("<<< value:[" << value << "]");
 476                                 int nType = atoi(value->toString().c_str());
 477                                 if(m_serviceId == nType)
 478                                 {
 479                                         m_result.push_back(TRUE);
 480                                         LoggerD("<<< Type is same");
 481                                 }
 482                                 else
 483                                 {
 484                                         m_result.push_back(FALSE);
 485                                         LoggerD("<<< Type is different");
 486                                 }
 487                                 return;
 488                         }
 489                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_CONVERSATION_ID)==0){
 490                                 LoggerD("<<< value:[" << value << "]");
 491                                 int nType = atoi(value->toString().c_str());
 492                                 if(m_conversationId == nType)
 493                                 {
 494                                         m_result.push_back(TRUE);
 495                                         LoggerD("<<< conversationID is same");
 496                                 }
 497                                 else
 498                                 {
 499                                         m_result.push_back(FALSE);
 500                                         LoggerD("<<< conversationID is different");
 501                                 }
 502                                 return;
 503                         }
 504                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_TYPE)==0){
 505                                 LoggerD("<<< value:[" << value << "]");
 506                                 m_currentType = value->toString();
 507                                 m_messageType = convertMessageType(m_currentType);
 508                                 if((int)m_type == m_messageType)
 509                                 {
 510                                         m_result.push_back(TRUE);
 511                                         LoggerD("<<< Type is same");
 512                                 }
 513                                 else
 514                                 {
 515                                         m_result.push_back(FALSE);
 516                                         LoggerD("<<< Type is different");
 517                                 }
 518                                 return;
 519                                 }
 520                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_FOLDER_ID)==0){
 521                                 LoggerD("<<< value:[" << value << "]");
 522                                 int nType = atoi(value->toString().c_str());
 523                                 if((int)m_folder == nType)
 524                                 {
 525                                         m_result.push_back(TRUE);
 526                                         LoggerD("<<< folder is same");
 527                                 }
 528                                 else
 529                                 {
 530                                         m_result.push_back(FALSE);
 531                                         LoggerD("<<< folder is different");
 532                                 }
 533                                 return;
 534                         }
 535                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_IS_READ)==0){
 536                                 LoggerD("<<< value:[" << value << "]");
 537                                 std::string lowerString;
 538                                 lowerString.assign(value->toString());
 539                                 StrLowChange(lowerString);
 540                                 int nType = lowerString.compare("true");
 541                                 if((int)m_isRead != nType)
 542                                 {
 543                                         m_result.push_back(TRUE);
 544                                         LoggerD("<<< isRead is same");
 545                                 }
 546                                 else
 547                                 {
 548                                         m_result.push_back(FALSE);
 549                                         LoggerD("<<< isRead is different");
 550                                 }
 551                                 return;
 552                         }
 553                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_HAS_ATTACHMENT)==0){
 554                                 LoggerD("<<< value:[" << value << "]");
 555                                 std::string lowerString;
 556                                 lowerString.assign(value->toString());
 557                                 StrLowChange(lowerString);
 558                                 int nType = lowerString.compare("true");
 559                                 if((int)m_hasAttachment != nType)
 560                                 {
 561                                         m_result.push_back(TRUE);
 562                                         LoggerD("<<< isRead is same");
 563                                 }
 564                                 else
 565                                 {
 566                                         m_result.push_back(FALSE);
 567                                         LoggerD("<<< isRead is different");
 568                                 }
 569                                 return;
 570                         }
 571                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_MESSAGE_STATUS)==0){
 572                                 LoggerD("<<< value:[" << value->toString() << "]");
 573                                 std::string convertStatus = value->toString();
 574                                 int nStatus = convertMessageStatus(convertStatus);
 575                                 if((int)m_messageStatus == nStatus)
 576                                 {
 577                                         m_result.push_back(TRUE);
 578                                         LoggerD("<<< folder is same");
 579                                 }
 580                                 else
 581                                 {
 582                                         m_result.push_back(FALSE);
 583                                         LoggerD("<<< folder is different");
 584                                 }
 585                                 return;
 586                         }
 587                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_PRIORITY)==0){
 588                                 LoggerD("<<< value:[" << value->toString() << "]");
 589                                 std::string lowerString;
 590                                 lowerString.assign(value->toString());
 591                                 StrLowChange(lowerString);
 592                                 if(lowerString.compare("true"))
 593                                 {
 594                                         if((int)m_priority == MessagePriority::Priority::HIGH)
 595                                         {
 596                                                 m_result.push_back(TRUE);
 597                                                 LoggerD("<<< priority is HIGH");
 598                                         }
 599                                         else
 600                                         {
 601                                                 m_result.push_back(FALSE);
 602                                                 LoggerD("<<< priority is LOW OR NORMAL");
 603                                         }
 604                                 }
 605                                 else if(lowerString.compare("false") == 0)
 606                                 {
 607                                         if((int)m_priority == MessagePriority::Priority::NORMAL)
 608                                         {
 609                                                 m_result.push_back(FALSE);
 610                                                 LoggerD("<<< priority is HIGH");
 611                                         }
 612                                         else
 613                                         {
 614                                                 m_result.push_back(TRUE);
 615                                                 LoggerD("<<< priority is LOW OR NORMAL");
 616                                         }
 617                                 }
 618                                 return;
 619                         }
 620                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_BODY)==0){
 621                                 LoggerD("<<< value:[" << value << "]");
 622                                 LoggerD("<<< value->toString():[" << value->toString() << "]");
 623                                 LoggerD("<<< m_body:[" << m_body << "]");
 624
 625                                 valueString = m_body;
 626                                 if(getMatchFlagResult(value, valueString, matchFlag))
 627                                 {
 628                                         m_result.push_back(TRUE);
 629                                         LoggerD("<<< body is same");
 630                                 }
 631                                 else
 632                                 {
 633                                         m_result.push_back(FALSE);
 634                                         LoggerD("<<< body is different");
 635                                 }
 636                                 return;
 637                         }
 638
 639                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_SUBJECT)==0){
 640                                 LoggerD("<<< value:[" << value << "]");
 641                                 LoggerD("<<< value->toString():[" << value->toString() << "]");
 642                                 LoggerD("<<< m_subject:[" << m_subject << "]");
 643
 644                                 valueString = m_subject;
 645                                 if(getMatchFlagResult(value, valueString, matchFlag))
 646                                 {
 647                                         m_result.push_back(TRUE);
 648                                         LoggerD("<<< subject is same");
 649                                 }
 650                                 else
 651                                 {
 652                                         m_result.push_back(FALSE);
 653                                         LoggerD("<<< subject is different");
 654                                 }
 655                                 return;
 656                         }
 657
 658                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 659                                 LoggerD("<<< value:[" << value << "]");
 660                                 LoggerD("<<< value->toString():[" << value->toString() << "]");
 661                                 LoggerD("<<< m_from:[" << m_from << "]");
 662
 663                                 valueString = m_from;
 664                                 if(getMatchFlagResult(value, valueString, matchFlag))
 665                                 {
 666                                         m_result.push_back(TRUE);
 667                                         LoggerD("<<< from is same");
 668                                 }
 669                                 else
 670                                 {
 671                                         m_result.push_back(FALSE);
 672                                         LoggerD("<<< from is different");
 673                                 }
 674                                 return;
 675                         }
 676
 677                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_TO)==0){
 678                                 LoggerD("<<< value:[" << value << "]");
 679                                 LoggerD("<<< value->toString():[" << value->toString() << "]");
 680                                 LoggerD("<<< m_to.size :[" << m_to.size() << "]");
 681
 682                                 bool result = FALSE;
 683                                 for(unsigned int i=0; i < m_to.size(); i++)
 684                                 {
 685                                         valueString = m_to[i];
 686                                         result = result || getMatchFlagResult(value, valueString, matchFlag);
 687                                 }
 688                                 LoggerD("<<< to compare result is :" << result);
 689                                 m_result.push_back(result);
 690                                 return;
 691                         }
 692
 693                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_CC)==0){
 694                                 LoggerD("<<< value:[" << value << "]");
 695                                 LoggerD("<<< value->toString():[" << value->toString() << "]");
 696                                 LoggerD("<<< m_cc.size :[" << m_cc.size() << "]");
 697
 698                                 bool result = FALSE;
 699                                 for(unsigned int i=0; i < m_cc.size(); i++)
 700                                 {
 701                                         valueString = m_cc[i];
 702                                         result = result || getMatchFlagResult(value, valueString, matchFlag);
 703                                 }
 704                                 LoggerD("<<< cc compare result is : " << result);
 705                                 m_result.push_back(result);
 706                                 return;
 707                         }
 708
 709                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_BCC)==0){
 710                                 LoggerD("<<< value:[" << value << "]");
 711                                 LoggerD("<<< value->toString():[" << value->toString() << "]");
 712                                 LoggerD("<<< m_cc.size :[" << m_bcc.size() << "]");
 713
 714                                 bool result = FALSE;
 715                                 for(unsigned int i=0; i < m_bcc.size(); i++)
 716                                 {
 717                                         valueString = m_bcc[i];
 718                                         result = result || getMatchFlagResult(value, valueString, matchFlag);
 719                                 }
 720                                 LoggerD("<<< bcc compare result is : " << result);
 721                                 m_result.push_back(result);
 722                                 return;
 723                         }
 724
 725                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_IS_RESPONSE_TO)==0){
 726                                 LoggerD("<<< value:[" << value << "]");
 727                                 int nType = atoi(value->toString().c_str());
 728                                 if(m_isResponseTo == nType)
 729                                 {
 730                                         m_result.push_back(TRUE);
 731                                         LoggerD("<<< conversationID is same");
 732                                 }
 733                                 else
 734                                 {
 735                                         m_result.push_back(FALSE);
 736                                         LoggerD("<<< conversationID is different");
 737                                 }
 738                                 return;
 739                         }
 740                         LoggerD(">>>");
 741                 }
 742
 743                 int StorageChangesMessageGenerator::convertMessageType(std::string& stringType){
 744                         LoggerD("<<< stringType:[" << stringType << "]");
 745
 746                         int retMessageType = -1;
 747
 748                         if(stringType.compare("messaging.sms") ==0){
 749                                 retMessageType = SMS;
 750                         }else if(stringType.compare("messaging.mms") ==0){
 751                                 retMessageType = MMS;
 752                         }else if(stringType.compare("messaging.email") ==0){
 753                                 retMessageType = EMAIL;
 754                         }else{
 755                                 LoggerE("invalid type:[" << stringType << "]");
 756                                 return -1;
 757                         }
 758
 759                         LoggerD(">>> retMessageType:" << retMessageType);
 760                         return retMessageType;
 761                 }
 762
 763                 int StorageChangesMessageGenerator::convertFolderType(std::string& stringType){
 764                         LoggerD("<<< stringType:[" << stringType << "]");
 765
 766                         int retMessageType = -1;
 767
 768                         if(stringType.compare("INBOX") ==0){
 769                                 retMessageType = INBOX;
 770                         }else if(stringType.compare("OUTBOX") ==0){
 771                                 retMessageType = OUTBOX;
 772                         }else if(stringType.compare("DRAFTBOX") ==0){
 773                                 retMessageType = DRAFTBOX;
 774                         }else if(stringType.compare("SENTBOX") ==0){
 775                                 retMessageType = SENTBOX;
 776                         }else{
 777                                 LoggerE("invalid type:[" << stringType << "]");
 778                                 return -1;
 779                         }
 780
 781                         LoggerD(">>> retMessageType:" << retMessageType);
 782                         return retMessageType;
 783                 }
 784
 785                 int StorageChangesMessageGenerator::convertMessageStatus(std::string& stringStatus){
 786                         LoggerD("<<< stringType:[" << stringStatus << "]");
 787
 788                         int retMessageStatus = -1;
 789
 790                         if(stringStatus.compare("SENT") ==0){
 791                                 retMessageStatus = MESSAGE_STATUS_SENT;
 792                         }else if(stringStatus.compare("SENDING") ==0){
 793                                 retMessageStatus = MESSAGE_STATUS_SENDING;
 794                         }else if(stringStatus.compare("FAILED") ==0){
 795                                 retMessageStatus = MESSAGE_STATUS_FAILED;
 796                         }else if(stringStatus.compare("DRAFT") ==0){
 797                                 retMessageStatus = MESSAGE_STATUS_DRAFT;
 798                         }else{
 799                                 LoggerE("invalid type:[" << stringStatus << "]");
 800                                 return -1;
 801                         }
 802
 803                         LoggerD(">>> retMessageType:" << retMessageStatus);
 804                         return retMessageStatus;
 805                 }
 806
 807                 void StorageChangesMessageGenerator::visitAttributeRange(std::string& attrName, DeviceAPI::Tizen::AnyPtr& initialValue, DeviceAPI::Tizen::AnyPtr& endValue, int depth) {
 808                         struct tm startTime;
 809                         struct tm endTime;
 810                         bool result = FALSE;
 811
 812                         string initialValueStr;
 813                         string endValueStr;
 814
 815                         if(initialValue == NULL || endValue == NULL)
 816                                 return;
 817
 818                         if(attrName.compare(StorageChangesMessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP)==0){
 819 //                              startTime = convertToTimeFormat(initialValueStr);
 820 //                              endTime = convertToTimeFormat(endValueStr);
 821
 822                                 if (!initialValue->isNullOrUndefined()) {
 823                                         if( initialValue->isType(DeviceAPI::Tizen::PrimitiveType_Time) ) {
 824                                                 LoggerD("<<<initialValue->getType()[PrimitiveType_Time]");
 825                                                 startTime = *initialValue->getDateTm();
 826                                         }
 827                                         else {
 828                                                 LoggerE("initialValue->getType()");
 829                                                 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid initialValue Type");
 830                                         }
 831                                 }
 832
 833                                 if (!endValue->isNullOrUndefined()) {
 834                                         if( endValue->isType(DeviceAPI::Tizen::PrimitiveType_Time) ) {
 835                                                 LoggerD("<<<initialValue->getType()[PrimitiveType_Time]");
 836                                                 endTime = *endValue->getDateTm();
 837                                                 LoggerD("<<<valueStr[" << endValueStr <<"]");
 838                                         } else {
 839                                                 LoggerE("endValue->getType()");
 840                                                 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid endValue Type");
 841                                         }
 842                                 }
 843
 844                                 result = getBetweenRangeClause(startTime, endTime);
 845                                 if(result == TRUE)
 846                                 {
 847                                         LoggerD("<<< timestamp is in range");
 848                                         m_result.push_back(TRUE);
 849                                 }else{
 850                                         LoggerD("<<< timestamp is out of range");
 851                                         m_result.push_back(FALSE);
 852                                 }
 853                         }
 854                 }
 855
 856                 bool StorageChangesMessageGenerator::getMatchFlagResult(DeviceAPI::Tizen::AnyPtr& value, std::string& valueString, MatchFlag& matchFlag)
 857                 {
 858                                 std::vector<std::string>::iterator iter;
 859                         bool result = FALSE;
 860                         if(matchFlag == DeviceAPI::Tizen::MATCH_EXACTLY){
 861                                 LoggerD("STRING_MATCH_EXACTLY");
 862                                 result = result || getMatchExactlyClause(valueString, value);
 863                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_FULLSTRING){
 864                                 LoggerD("STRING_MATCH_FULLSTRING");
 865                                 result = result || getMatchFullstringClause(valueString, value);
 866                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_CONTAINS){
 867                                 LoggerD("STRING_MATCH_CONTAINS");
 868                                 result = result || getMatchContainsClause(valueString, value);
 869                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_STARTSWITH){
 870                                 LoggerD("STRING_MATCH_STARTSWITH");
 871                                 result = result || getMatchStartwithClause(valueString, value);
 872                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_ENDSWITH){
 873                                 LoggerD("STRING_MATCH_ENDSWITH");
 874                                 result = result || getMatchEndwithClause(valueString, value);
 875                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_EXISTS){
 876                                 LoggerD("STRING_MATCH_EXIST");
 877                                 result = result || getMatchExistClause(valueString);
 878                         }else{
 879                                 LoggerD("[ERROR]invalid match flag : iter:" << *iter);
 880                         }
 881                         return result;
 882                 }
 883
 884                 bool StorageChangesMessageGenerator::getCompareResult()
 885                 {
 886                         bool result;
 887                         LoggerD("m_result.size() " << m_result.size());
 888                         result = m_result.back();
 889                         m_result.pop_back();
 890                         LoggerD("result = " << result);
 891                         return result;
 892                 }
 893
 894                 void StorageChangesMessageGenerator::StrLowChange(std::string& tempString)
 895                 {
 896                         std::transform(tempString.begin(), tempString.end(), tempString.begin(), ::tolower);
 897                         return;
 898                 }
 899
 900
 901         }
 902 }