src/platform/Tizen/Messaging/MessageQueryGenerator.cpp

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16 /*
  17  * MessageQueryGenerator.cpp
  18  *
  19  *  Created on: 2011. 10. 28.
  20  *      Author: sangtai
  21  */
  22
  23 #include "MessageQueryGenerator.h"
  24 #include "API/Messaging/MessageFilterValidatorFactory.h"
  25 #include "API/Messaging/ConversationFilterValidatorFactory.h"
  26
  27 #include <API/Messaging/IMessagingTypes.h>
  28 #include <API/Messaging/log.h>
  29 #include <Commons/Exception.h>
  30
  31 #include <emf-types.h>
  32
  33 #include <dpl/log/log.h>
  34
  35 using namespace std;
  36 using namespace TizenApis::Api::Tizen;
  37
  38 namespace TizenApis {
  39
  40         namespace Platform {
  41                 namespace Messaging {
  42
  43                 const std::string MessageQueryGenerator::STRING_MATCH_EXCACTLY        = "EXACTLY";
  44                 const std::string MessageQueryGenerator::STRING_MATCH_CONTAINS        = "CONTAINS";
  45                 const std::string MessageQueryGenerator::STRING_MATCH_STARTSWITH      = "STARTSWITH";
  46                 const std::string MessageQueryGenerator::STRING_MATCH_ENDSWITH        = "ENDSWITH";
  47 //              const std::string MessageQueryGenerator::STRING_MATCH_CASESENSITIVE   = "CASESENSITIVE";
  48
  49                 const std::string MessageQueryGenerator::STRING_WHERE   = "WHERE ";
  50                 const std::string MessageQueryGenerator::STRING_SUFFIX  = "";
  51                 const std::string MessageQueryGenerator::STRING_DIRECTION = "A.MSG_DIRECTION";
  52
  53                 const int MessageQueryGenerator::MESSAGE_TYPE_NOT_INITIALIZED = -1;
  54
  55                 MessageQueryGenerator::MessageQueryGenerator():m_messageType(MESSAGE_TYPE_NOT_INITIALIZED) {
  56                         m_query.append(getQueryPrefix());
  57
  58                         m_limit     = 0;
  59                         m_offset    = 0;
  60                         m_mode = MODE_EMAIL;
  61
  62                         initAttributeMap();
  63                 }
  64
  65                 MessageQueryGenerator::MessageQueryGenerator(const Api::Tizen::SortModePtr& sortMode, const long limit, const long offset):
  66                                 m_messageType(MESSAGE_TYPE_NOT_INITIALIZED){
  67                         LogDebug("<<< limit:" << limit << ", offset:" << offset);
  68
  69                         m_query.append(getQueryPrefix());
  70
  71                         //TODO check sort mode validation
  72                         m_sortMode = sortMode;
  73
  74                         m_limit = limit;
  75                         m_offset = offset;
  76                         m_mode = MODE_EMAIL;
  77
  78                         initAttributeMap();
  79                 }
  80
  81                 MessageQueryGenerator::~MessageQueryGenerator() {
  82                 }
  83
  84                 void MessageQueryGenerator::reset(QueryGeneratorMode mode){
  85                         m_query.clear();
  86                         m_queryVector.clear();
  87
  88                         m_limit     = 0;
  89                         m_offset    = 0;
  90                         m_mode      = mode;
  91
  92                         m_query.append(getQueryPrefix());
  93
  94                         initAttributeMap();
  95                 }
  96
  97                 void MessageQueryGenerator::setEmailAttributeMap(){
  98                         attributeMap.clear();
  99
 100                         attributeMap.insert(
 101                                                                                         std::pair<std::string, std::string>(
 102                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_ID,             "mail_id"));
 103                         attributeMap.insert(
 104                                                                                         std::pair<std::string, std::string>(
 105                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_FOLDER,          "mailbox_type"));
 106                         attributeMap.insert(
 107                                                                                         std::pair<std::string, std::string>(
 108                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP,       "date_time"));
 109                         attributeMap.insert(
 110                                                                                         std::pair<std::string, std::string>(
 111                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_FROM,            "full_address_from"));
 112                         attributeMap.insert(
 113                                                                                         std::pair<std::string, std::string>(
 114                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TO,              "full_address_to"));
 115                         attributeMap.insert(
 116                                                                                         std::pair<std::string, std::string>(
 117                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_CC,              "full_address_cc"));
 118                         attributeMap.insert(
 119                                                                                         std::pair<std::string, std::string>(
 120                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_BCC,             "full_address_bcc"));
 121                         attributeMap.insert(
 122                                                                                         std::pair<std::string, std::string>(
 123                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_BODY,            "preview_text"));             //TODO check
 124                         attributeMap.insert(
 125                                                                                         std::pair<std::string, std::string>(
 126                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_IS_READ,          "mail_status"));     //TODO 1:seen, 2:deleted, 4:flagged, 8:answered, 20:draft
 127                         attributeMap.insert(
 128                                                                                         std::pair<std::string, std::string>(
 129                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_PRIORITY,         "priority"));
 130                         attributeMap.insert(
 131                                                                                         std::pair<std::string, std::string>(
 132                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_SUBJECT,          "subject"));
 133                         attributeMap.insert(
 134                                                                                         std::pair<std::string, std::string>(
 135                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TYPE,             "type"));
 136
 137                         attributeMap.insert(
 138                                                                                         std::pair<std::string, std::string>(
 139                                                                                                         ConversationFilterValidatorFactory::ATTRIBUTE_MESSAGE_COUNT,  "thread_item_count"));
 140                 }
 141
 142                 void MessageQueryGenerator::setSmsMmsAttributeMap(){
 143                         LogDebug("<<<");
 144                         attributeMap.clear();
 145
 146                         attributeMap.insert(
 147                                                                                                                 std::pair<std::string, std::string>(
 148                                                                                                                                 MessageFilterValidatorFactory::ATTRIBUTE_ID,          "A.MSG_ID"));
 149                         attributeMap.insert(
 150                                                                                         std::pair<std::string, std::string>(
 151                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_FOLDER,          "A.FOLDER_ID"));
 152                         attributeMap.insert(
 153                                                                                         std::pair<std::string, std::string>(
 154                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP,       "A.DISPLAY_TIME"));
 155 //TODO check sms mms attribute frome, to, cc, bcc
 156                                                 attributeMap.insert(
 157                                                                                         std::pair<std::string, std::string>(
 158                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_FROM,            "B.ADDRESS_VAL"));
 159                         attributeMap.insert(
 160                                                                                         std::pair<std::string, std::string>(
 161                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TO,              "B.ADDRESS_VAL"));
 162 //                      attributeMap.insert(
 163 //                                                                                      std::pair<std::string, std::string>(
 164 //                                                                                                      MessageFilterValidatorFactory::ATTRIBUTE_CC,              "full_address_cc"));
 165 //                      attributeMap.insert(
 166 //                                                                                      std::pair<std::string, std::string>(
 167 //                                                                                                      MessageFilterValidatorFactory::ATTRIBUTE_BCC,             "full_address_bcc"));
 168                         attributeMap.insert(
 169                                                                                         std::pair<std::string, std::string>(
 170                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_BODY,            "A.MSG_TEXT"));
 171                         attributeMap.insert(
 172                                                                                         std::pair<std::string, std::string>(
 173                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_IS_READ,          "A.READ_STATUS"));   //TODO 1:seen, 2:deleted, 4:flagged, 8:answered, 20:draft
 174                         attributeMap.insert(
 175                                                                                         std::pair<std::string, std::string>(
 176                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_PRIORITY,         "A.PRIORITY"));
 177                         attributeMap.insert(
 178                                                                                         std::pair<std::string, std::string>(
 179                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_SUBJECT,          "A.SUBJECT"));
 180                         attributeMap.insert(
 181                                                                                         std::pair<std::string, std::string>(
 182                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TYPE,             "A.MAIN_TYPE"));
 183
 184                         LogDebug(">>");
 185                 }
 186
 187                 void MessageQueryGenerator::initAttributeMap(){
 188                         switch (m_mode){
 189                                 case MODE_EMAIL:
 190                                         LogDebug("MODE_EMAIL");
 191                                         setEmailAttributeMap();
 192                                         break;
 193                                 case MODE_SMS_MMS:
 194                                         LogDebug("MODE_SMS_MMS");
 195                                         setSmsMmsAttributeMap();
 196                                         break;
 197                                 default: //TODO throw exception
 198                                         ;
 199                         }
 200                 }
 201
 202                 void MessageQueryGenerator::visitPreComposite(Api::Tizen::FilterType& type, int depth){
 203                         LogDebug("<<<");
 204                         m_queryVector.push_back("(");
 205                         LogDebug(">>>");
 206                 }
 207
 208                 void MessageQueryGenerator::visitInComposite(Api::Tizen::FilterType& type, int depth){
 209                         LogDebug("<<<");
 210
 211                         if(m_typeProcessing == 1){
 212                                 m_typeProcessing = 0;
 213
 214                                 if(type != INTERSECTION_FILTER){
 215                                         LogError("[ERROR] >>> invalid Filter type:" << type);
 216                                         ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
 217                                 }
 218
 219                                 LogDebug(">>>");
 220                                 return;
 221                         }
 222
 223                         if(type == INTERSECTION_FILTER){
 224                                 m_queryVector.push_back("AND");
 225                         }
 226 //                      else if(type == UNION_FILTER){
 227 //                              m_queryVector.push_back("OR");
 228 //                      }
 229                         else{
 230                                 LogError("[ERROR] invalid Filter type:" << type);
 231                                 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
 232                         }
 233
 234                         LogDebug(">>>");
 235                 }
 236
 237                 void MessageQueryGenerator::visitPostComposite(Api::Tizen::FilterType& type, int depth){
 238                         LogDebug("<<<");
 239                         if(m_typeProcessing == 1){
 240                                 m_typeProcessing = 0;
 241                                 m_queryVector.erase(m_queryVector.end());
 242                         }else{
 243                         }
 244
 245                         m_queryVector.push_back(")");
 246                         LogDebug(">>>");
 247                 }
 248
 249                 std::string MessageQueryGenerator::convertToEmfAttrName(std::string attrName){
 250                         LogDebug("<<< attrName:[" << attrName << "]");
 251
 252                         std::string retString;
 253
 254                         std::map<std::string, std::string>::iterator it = attributeMap.find(attrName);
 255                         if(it == attributeMap.end()){
 256                                 MsgLogWanning("[WANNING] attribute not found : ["<< attrName << "]");
 257                         }else{
 258                                 retString = static_cast<std::string>(attributeMap.find(attrName)->second);
 259                         }
 260
 261                         LogDebug(">> retString:[" << retString << "]");
 262                         return retString;
 263                 }
 264
 265                 std::string MessageQueryGenerator::createTimeString(std::string& timeString)
 266                 {
 267                         LogDebug("<<< timeString:[" << timeString << "]");
 268
 269                         size_t pos = timeString.find("-",0);
 270                         while(pos!= std::string::npos){
 271                                 timeString.erase(pos,1);
 272                                 pos = timeString.find('-',0);
 273                         }
 274
 275                         LogDebug(">>> timeString:[" << timeString << "]");
 276                         return timeString;
 277                 }
 278
 279                 std::string MessageQueryGenerator::createFolderType(std::string& value)
 280                 {
 281                         LogDebug("<<< value:[" << value << "]");
 282                         std::string retFolderType;
 283                         std::ostringstream outstream;
 284
 285                         if(value.compare("INBOX") == 0){
 286                                 outstream << EMF_MAILBOX_TYPE_INBOX;
 287                         }else if(value.compare("OUTBOX") == 0){
 288                                 outstream << EMF_MAILBOX_TYPE_OUTBOX;
 289                         }else if(value.compare("DRAFTBOX") == 0){
 290                                 outstream << EMF_MAILBOX_TYPE_DRAFT;
 291                         }else if(value.compare("SENTBOX") == 0){
 292                                 outstream << EMF_MAILBOX_TYPE_SENTBOX;
 293                         }else{
 294                                 LogDebug("[ERROR] unsupported type:["<< value << "]");
 295                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid folder id");
 296                         }
 297
 298                         retFolderType = outstream.str();
 299
 300                         LogDebug(">>> retFolderType:[" << retFolderType << "]");
 301                         return retFolderType;
 302                 }
 303
 304                 std::string MessageQueryGenerator::createPriorityTypeForEmail(std::string& value)
 305                 {
 306                         LogDebug("<<< value:[" << value << "]");
 307                         std::string retPriorityType;
 308
 309                         if(value.compare("true")==0){
 310                                 retPriorityType = "1";
 311                         }else{
 312                                 retPriorityType = "3 OR priority=5";
 313                         }
 314
 315                         return retPriorityType;
 316                 }
 317
 318                 std::string MessageQueryGenerator::createPriorityTypeForSmsMms(std::string& value){
 319                         LogDebug("<<< value:[" << value << "]");
 320                         std::string retPriorityType;
 321
 322                         if(value.compare("true")==0){
 323                                 retPriorityType = "1";
 324                         }else if(value.compare("false")==0){
 325                                 retPriorityType = "0";
 326                         }else{
 327                                 LogError(">>> invalid value:[" << value << "]");
 328                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "unsupported value");
 329                         }
 330
 331                         return retPriorityType;
 332                 }
 333
 334
 335                 std::string MessageQueryGenerator::convertToTimeFormat(const std::string& timeString){
 336                         LogDebug("<<< timeString:[" << timeString << "]");
 337
 338                         std::string retString;
 339                         retString.append("'");
 340
 341                         int yearLength = 4;
 342                         int nextStart = 0;
 343                         retString.append(timeString.substr(0, yearLength));
 344                         retString.append("-");
 345                         nextStart = nextStart + yearLength;
 346
 347                         int monthLength = 2;
 348                         retString.append(timeString.substr(nextStart, monthLength));
 349                         retString.append("-");
 350                         nextStart = nextStart + monthLength;
 351
 352                         int dateLength = 2;
 353                         retString.append(timeString.substr(nextStart, dateLength));
 354                         retString.append(" ");
 355                         nextStart = nextStart + dateLength;
 356
 357                         int hourLength = 2;
 358                         retString.append(timeString.substr(nextStart, hourLength));
 359                         retString.append(":");
 360                         nextStart = nextStart + hourLength;
 361
 362                         int minuteLength = 2;
 363                         retString.append(timeString.substr(nextStart, minuteLength));
 364                         retString.append(":");
 365                         nextStart = nextStart + minuteLength;
 366
 367                         int secondLength = 2;
 368                         retString.append(timeString.substr(nextStart, secondLength));
 369                         retString.append("'");
 370
 371                         LogDebug(">>> retString:[" << retString << "]");
 372                         return retString;
 373                 }
 374
 375                 //convert from '20111115000000' to 2011-11-15 00:00:00
 376                 std::string MessageQueryGenerator::createDateTimeTypeForSmsMms(Api::Tizen::AnyPtr& value){
 377                         LogDebug("<<< value:[" << value->toString() << "]");
 378
 379                         std::string tmpValueString = value->toString();
 380                         std::string secondsSinceType;
 381                         secondsSinceType.append("strftime('%s', ");                     //SQL time format function
 382                         if(m_mode == MODE_SMS_MMS){
 383                                 tmpValueString = convertToTimeFormat(tmpValueString);
 384                         }
 385
 386                         secondsSinceType.append(tmpValueString);
 387                         secondsSinceType.append(")");
 388
 389                         LogDebug(">>> retPriorityType:[" << secondsSinceType << "]");
 390                         return secondsSinceType;
 391                 }
 392
 393                 std::string MessageQueryGenerator::createDateTimeTypeForEmail(Api::Tizen::AnyPtr& value)
 394                 {
 395                         LogDebug("<<< value:[" << value->toString() << "]");
 396
 397                         if(value->getType() != PrimitiveType_Time){
 398                                 LogError("[ERROR]>> invalid type");
 399                                 return NULL;
 400                         }
 401
 402                         std::string retPriorityType;
 403                         retPriorityType = value->toString();
 404
 405                         return retPriorityType;
 406                 }
 407
 408                 std::string MessageQueryGenerator::convertBooleanStringToIntegerString(std::string& booleanString){
 409                         std::string retString;
 410
 411                         if(booleanString.compare("true") == 0){
 412                                 retString = "1";
 413                         }else if(booleanString.compare("false") == 0){
 414                                 retString = "0";
 415                         }else{
 416                                 LogError("invalid booleanString:[" << booleanString << "]");
 417                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid booleanString :[" + booleanString + "]");
 418                         }
 419                         return retString;
 420                 }
 421
 422                 std::string MessageQueryGenerator::getMatchExactlyClause(std::string& attrName, Api::Tizen::AnyPtr& value)
 423                 {
 424                         std::string retClause;
 425                         std::string valueString = value->toString();
 426                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 427
 428                         do{
 429                                 if(m_mode == MODE_EMAIL){
 430                                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 431                                                 retClause = emfAttributeName + " LIKE '%%<" + valueString +">'";
 432                                                 break;
 433                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP)==0){
 434                                                 retClause = emfAttributeName + "=" + createDateTimeTypeForEmail(value);
 435                                                 break;
 436                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_PRIORITY)==0){
 437                                                 retClause = emfAttributeName + "=" + createPriorityTypeForEmail(valueString);
 438                                                 break;
 439                                         }
 440                                 }else if(m_mode == MODE_SMS_MMS){
 441                                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 442                                                 retClause = "("+emfAttributeName + " ='"+ valueString + "' AND " + getMessageDirectionString() + "=1)";
 443                                                 break;
 444                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TO)==0){
 445                                                 retClause = "("+emfAttributeName + " ='"+ valueString + "' AND " + getMessageDirectionString() + "=0)";
 446                                                 break;
 447                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP)==0){
 448                                                 retClause = emfAttributeName + "=" + createDateTimeTypeForSmsMms(value); //TODO need to check
 449                                                 break;
 450                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_PRIORITY)==0){
 451                                                 retClause = emfAttributeName + "=" + createPriorityTypeForSmsMms(valueString);
 452                                                 break;
 453                                         }
 454                                 }
 455
 456                                 if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_IS_READ)==0){
 457                                         retClause = emfAttributeName + "=" + convertBooleanStringToIntegerString(valueString);
 458                                 }       else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FOLDER)==0){
 459                                         retClause = emfAttributeName + "=" + createFolderType(valueString);
 460                                 }else{
 461                                         retClause = emfAttributeName + " = '" + value->toString() + "'"; //TODO need to check
 462                                 }
 463                         }while(false);
 464
 465                         return retClause;
 466                 }
 467
 468                 std::string MessageQueryGenerator::getMatchStartsWithClause(std::string& attrName, TizenApis::Api::Tizen::AnyPtr& value){
 469                         std::string retClause;
 470                         std::string valueString = value->toString();
 471                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 472
 473                         do{
 474                                 if(m_mode == MODE_EMAIL){
 475                                 }else if(m_mode == MODE_SMS_MMS){
 476                                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 477                                                 retClause.append("(" + emfAttributeName + " LIKE '" + value->toString() +
 478                                                                 "%%' AND " + getMessageDirectionString() + "=1) ");
 479                                                 break;
 480                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TO)==0){
 481                                                 retClause.append("(" + emfAttributeName + " LIKE '" + value->toString() +
 482                                                                 "%%' AND " + getMessageDirectionString() +"=0) ");
 483                                                 break;
 484                                         }
 485                                 }
 486
 487                                 retClause.append(emfAttributeName + " LIKE '" + value->toString() +"%%'");
 488                         }while(false);
 489
 490                         return retClause;
 491                 }
 492
 493                 std::string MessageQueryGenerator::getMessageDirectionString(){
 494                         return MessageQueryGenerator::STRING_DIRECTION;
 495                 }
 496
 497                 std::string MessageQueryGenerator::getMatchEndsWithClause(std::string& attrName, TizenApis::Api::Tizen::AnyPtr& value){
 498                         std::string retClause;
 499                         std::string valueString = value->toString();
 500                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 501
 502                         do{
 503                                 if(m_mode == MODE_EMAIL){
 504                                 }else if(m_mode == MODE_SMS_MMS){
 505                                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 506                                                 retClause.append("(" + emfAttributeName + " LIKE '%%" + value->toString() +
 507                                                                 "' AND "+ getMessageDirectionString() + "=1) ");
 508                                                 break;
 509                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TO)==0){
 510                                                 retClause.append("(" + emfAttributeName + " LIKE '%%" + value->toString() +
 511                                                                 "' AND " + getMessageDirectionString() + "=0) ");
 512                                                 break;
 513                                         }
 514                                 }
 515
 516                                 retClause.append(emfAttributeName + " LIKE '%%" + value->toString() +"'");
 517                         }while(false);
 518
 519                         return retClause;
 520                 }
 521
 522                 std::string MessageQueryGenerator::getMatchContainsClause(std::string& attrName, TizenApis::Api::Tizen::AnyPtr& value){
 523                         std::string retClause;
 524                         std::string valueString = value->toString();
 525                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 526
 527                         do{
 528                                 if(m_mode == MODE_EMAIL){
 529                                 }else if(m_mode == MODE_SMS_MMS){
 530                                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 531                                                 retClause.append("(" + emfAttributeName + " LIKE '%%" + value->toString() +
 532                                                                 "%%' AND " + getMessageDirectionString() + "=1) ");
 533                                                 break;
 534                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TO)==0){
 535                                                 retClause.append("(" + emfAttributeName + " LIKE '%%" + value->toString() +
 536                                                                 "%%' AND " + getMessageDirectionString() + "=0) ");
 537                                                 break;
 538                                         }
 539                                 }
 540
 541                                 retClause.append(emfAttributeName + " LIKE '%%" + value->toString() +"%%'");
 542                         }while(false);
 543
 544                         return retClause;
 545                 }
 546
 547                 void MessageQueryGenerator::visitAttribute(std::string& attrName,
 548                                 Api::Tizen::AnyArrayPtr& values, std::string& matchFlag, bool caseSensitive, int depth){
 549                         LogDebug("<<< attrName:[" << attrName << "], matchFlag:[" << matchFlag << "]");
 550                         LogDebug("values->size():" << values->size());
 551
 552                         Api::Tizen::FilterType filterType = UNION_FILTER;
 553
 554                         if(matchFlag.compare("EXIST")==0){
 555                                 //TODO implement for EXIST
 556                         }else if(values->size() == 1){
 557                                 AnyPtr matchValue = values->at(0);
 558                                 visitAttributeEach(attrName, matchValue, matchFlag, depth);
 559                         }else{
 560                                 visitPreComposite(filterType, depth);
 561
 562                                 AnyArray::iterator iter;
 563                                 for(iter=values->begin(); iter!= values->end(); iter++){
 564
 565                                         if(iter != values->begin()){
 566
 567                                                 visitInComposite(filterType, depth);
 568                                         }
 569
 570                                         AnyPtr matchValue = *iter;
 571                                         visitAttributeEach(attrName, matchValue, matchFlag, depth);
 572                                 }
 573
 574                                 visitPostComposite(filterType, depth);
 575                         }
 576                         LogDebug(">>>");
 577                 }
 578
 579                 int MessageQueryGenerator::convertMessageType(std::string& stringType){
 580                         LogDebug("<<< stringType:[" << stringType << "]");
 581
 582                         int retMessageType = -1;
 583
 584                         if(stringType.compare("tizen.sms") ==0){
 585                                 retMessageType = Api::Messaging::SMS;
 586                         }else if(stringType.compare("tizen.mms") ==0){
 587                                 retMessageType = Api::Messaging::MMS;
 588                         }else if(stringType.compare("tizen.email") ==0){
 589                                 retMessageType = Api::Messaging::EMAIL;
 590                         }else{
 591                                 MsgLogError("invalid type:[" << stringType << "]");
 592                                 return -1;
 593                         }
 594
 595                         LogDebug(">>> retMessageType:" << retMessageType);
 596                         return retMessageType;
 597                 }
 598
 599
 600                 void MessageQueryGenerator::visitAttributeEach(std::string& attrName, Api::Tizen::AnyPtr& value, std::string& matchFlag, int depth){
 601                         LogDebug("<<< attrName:[" << attrName << "], value:[" << value->toString() << "]");
 602
 603                         if(attrName.compare("type")==0){
 604                                 m_typeProcessing = 1;
 605                                 m_currentType = value->toString();
 606
 607                                 m_messageType = convertMessageType(m_currentType);
 608
 609                                 LogDebug(">>> skip type");
 610                                 return;
 611                         }
 612
 613                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 614
 615 //                      if(emfAttributeName == NULL){
 616 //                              LogDebug(">>> emfAttributeName is NULL");
 617 //                              return;
 618 //                      }
 619                         std::string tmpStringBuffer;
 620
 621                         if(matchFlag.compare(STRING_MATCH_EXCACTLY) == 0){
 622                                 LogDebug("STRING_MATCH_EXCACTLY");
 623                                 tmpStringBuffer.append(getMatchExactlyClause(attrName, value));
 624                         }else if(matchFlag.compare(STRING_MATCH_CONTAINS) == 0){
 625                                 LogDebug("STRING_MATCH_CONTAINS");
 626                                 tmpStringBuffer.append(getMatchContainsClause(attrName, value));
 627                         }else if(matchFlag.compare(STRING_MATCH_STARTSWITH) == 0){
 628                                 LogDebug("STRING_MATCH_STARTSWITH");
 629                                 tmpStringBuffer.append(getMatchStartsWithClause(attrName, value));
 630                         }else if(matchFlag.compare(STRING_MATCH_ENDSWITH) == 0){
 631                                 LogDebug("STRING_MATCH_ENDSWITH");
 632                                 tmpStringBuffer.append(getMatchEndsWithClause(attrName, value));
 633                         }else{
 634                                 LogDebug("[ERROR]invalid match flag[" << matchFlag << "]");
 635                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid match flag:[" + matchFlag + "]");
 636                         }
 637 //                              else if(iter->find(MATCH_CASESENSITIVE)){               //TODO check case sensitive
 638 //                              }
 639                         m_queryVector.push_back(tmpStringBuffer);
 640                         LogDebug(">>>");
 641                 }
 642
 643                 void MessageQueryGenerator::visitAttributeRange(std::string& attrName, Api::Tizen::AnyPtr& initialValue, Api::Tizen::AnyPtr& endValue, int depth) {
 644                         LogDebug("<<< sttrName:[" << attrName <<"]");
 645                         LogDebug("initialVAlue:[" << initialValue->toString() << "]");
 646                         LogDebug("endValue:[" << endValue->toString() << "]");
 647
 648                         std::string tmpStringBuffer;
 649
 650                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 651                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP)==0){
 652                                 if(m_mode == MODE_EMAIL){
 653                                         tmpStringBuffer.append(emfAttributeName + " BETWEEN " + initialValue->toString() + " AND " + endValue->toString());
 654                                 }else if(m_mode == MODE_SMS_MMS){
 655                                         tmpStringBuffer.append(emfAttributeName + " BETWEEN " +
 656                                                         createDateTimeTypeForSmsMms(initialValue) + " AND " +
 657                                                         createDateTimeTypeForSmsMms(endValue));
 658                                 }
 659                         }
 660
 661                         m_queryVector.push_back(tmpStringBuffer);
 662                         LogDebug(">>>");
 663                 }
 664
 665                 std::string MessageQueryGenerator::getQueryFromVector()
 666                 {
 667                         std::string retString;
 668
 669                         std::vector<string>::const_iterator it = m_queryVector.begin();
 670                         while(it != m_queryVector.end()){
 671                                 retString.append(*it);
 672                                 retString.append(" ");
 673                                 it++;
 674                         }
 675
 676                         LogDebug(">>> retString:" << retString);
 677                         return retString;
 678                 }
 679
 680                 std::string MessageQueryGenerator::getQuery(){
 681                         std::stringstream buffer;
 682
 683                         m_query.append(getQueryFromVector());
 684
 685                         if(m_query.compare(getQueryPrefix())==0){
 686                                 return "";
 687                         }else{
 688                                 if(m_sortMode != NULL){
 689                                         std::string platformAttrName = convertToEmfAttrName(m_sortMode->getAttributeName());
 690                                         std::string sortModeString;
 691                                         if(m_sortMode->getOrder() == ASCENDING_SORT_ORDER){
 692                                                 sortModeString = "ASC";
 693                                         }else{
 694                                                 sortModeString = "DESC";
 695                                         }
 696
 697                                         buffer << " ORDER BY " << platformAttrName << " " << sortModeString;
 698                                         if(m_limit != 0){
 699                                                 buffer << " LIMIT "  << m_offset  << "," << m_limit;
 700                                         }
 701                                 }
 702
 703                                 m_query.append(getQuerySuffix());
 704                                 m_query.append(buffer.str());
 705                                 return m_query;
 706                         }
 707                 }
 708
 709                 std::string MessageQueryGenerator::getQueryPrefix(){
 710                         return MessageQueryGenerator::STRING_WHERE;
 711                 }
 712
 713                 std::string MessageQueryGenerator::getQuerySuffix(){
 714                         return MessageQueryGenerator::STRING_SUFFIX;
 715                 }
 716
 717
 718
 719                 }
 720         }               //namespace Platform
 721 }               //namespace WrtPlugins