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 <email-types.h>
  32 #include <msg_storage_types.h>
  33 #include <sstream>
  34 #include <time.h>
  35
  36 #include <dpl/log/log.h>
  37
  38 using namespace std;
  39 using namespace TizenApis::Api::Tizen;
  40
  41 namespace TizenApis {
  42
  43         namespace Platform {
  44                 namespace Messaging {
  45
  46                 const std::string MessageQueryGenerator::STRING_MATCH_EXACTLY         = "EXACTLY";
  47                 const std::string MessageQueryGenerator::STRING_MATCH_CONTAINS        = "CONTAINS";
  48                 const std::string MessageQueryGenerator::STRING_MATCH_STARTSWITH      = "STARTSWITH";
  49                 const std::string MessageQueryGenerator::STRING_MATCH_ENDSWITH        = "ENDSWITH";
  50 //              const std::string MessageQueryGenerator::STRING_MATCH_CASESENSITIVE   = "CASESENSITIVE";
  51
  52                 const std::string MessageQueryGenerator::STRING_WHERE   = "WHERE ";
  53                 const std::string MessageQueryGenerator::STRING_SUFFIX  = "";
  54                 const std::string MessageQueryGenerator::STRING_DIRECTION = "A.MSG_DIRECTION";
  55
  56                 const int MessageQueryGenerator::MESSAGE_TYPE_NOT_INITIALIZED = -1;
  57
  58                 MessageQueryGenerator::MessageQueryGenerator():m_messageType(MESSAGE_TYPE_NOT_INITIALIZED) {
  59                         m_query.append(getQueryPrefix());
  60
  61                         m_limit     = 0;
  62                         m_offset    = 0;
  63                         m_mode = MODE_EMAIL;
  64
  65                         initAttributeMap();
  66                 }
  67
  68                 MessageQueryGenerator::MessageQueryGenerator(const Api::Tizen::SortModePtr& sortMode, const long limit, const long offset):
  69                                 m_messageType(MESSAGE_TYPE_NOT_INITIALIZED){
  70                         LogDebug("<<< limit:" << limit << ", offset:" << offset);
  71
  72                         m_query.append(getQueryPrefix());
  73
  74                         //TODO check sort mode validation
  75                         m_sortMode = sortMode;
  76
  77                         m_limit = limit;
  78                         m_offset = offset;
  79                         m_mode = MODE_EMAIL;
  80
  81                         initAttributeMap();
  82                 }
  83
  84                 MessageQueryGenerator::MessageQueryGenerator(const Api::Tizen::SortModePtr& sortMode, const long limit, const long offset, const int type):
  85                         m_messageType(MESSAGE_TYPE_NOT_INITIALIZED){
  86                         LogDebug("<<< limit:" << limit << ", offset:" << offset);
  87                         m_query.append(getQueryPrefix());
  88
  89                         //TODO check sort mode validation
  90                         m_sortMode = sortMode;
  91
  92                         m_limit = limit;
  93                         m_offset = offset;
  94                         m_serviceType = type;
  95
  96                         if(type == Api::Messaging::SMS)
  97                         {
  98                                 m_mode = MODE_SMS;
  99                         }
 100                         else if(type == Api::Messaging::MMS)
 101                         {
 102                                 m_mode = MODE_MMS;
 103                         }
 104                         else
 105                         {
 106                                 m_mode = MODE_EMAIL;
 107                         }
 108
 109                         initAttributeMap();
 110                 }
 111
 112
 113                 MessageQueryGenerator::~MessageQueryGenerator() {
 114                 }
 115
 116                 void MessageQueryGenerator::reset(QueryGeneratorMode mode){
 117                         m_query.clear();
 118                         m_queryVector.clear();
 119
 120                         m_limit     = 0;
 121                         m_offset    = 0;
 122                         m_mode      = mode;
 123
 124                         m_query.append(getQueryPrefix());
 125
 126                         initAttributeMap();
 127                 }
 128
 129                 void MessageQueryGenerator::setEmailAttributeMap(){
 130                         attributeMap.clear();
 131
 132                         attributeMap.insert(
 133                                                                                         std::pair<std::string, std::string>(
 134                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_ID,             "mail_id"));
 135                         attributeMap.insert(
 136                                                                                         std::pair<std::string, std::string>(
 137                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_SERVICE_ID,      "account_id"));
 138                         attributeMap.insert(
 139                                                                                         std::pair<std::string, std::string>(
 140                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_FOLDER,          "mailbox_id"));
 141                         attributeMap.insert(
 142                                                                                         std::pair<std::string, std::string>(
 143                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP,       "date_time"));
 144                         attributeMap.insert(
 145                                                                                         std::pair<std::string, std::string>(
 146                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_FROM,            "full_address_from"));
 147                         attributeMap.insert(
 148                                                                                         std::pair<std::string, std::string>(
 149                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TO,              "full_address_to"));
 150                         attributeMap.insert(
 151                                                                                         std::pair<std::string, std::string>(
 152                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_CC,              "full_address_cc"));
 153                         attributeMap.insert(
 154                                                                                         std::pair<std::string, std::string>(
 155                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_BCC,             "full_address_bcc"));
 156                         attributeMap.insert(
 157                                                                                         std::pair<std::string, std::string>(
 158                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_BODY,            "preview_text"));             //TODO check
 159                         attributeMap.insert(
 160                                                                                         std::pair<std::string, std::string>(
 161                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_IS_READ,          "mail_status"));     //TODO 1:seen, 2:deleted, 4:flagged, 8:answered, 20:draft
 162                         attributeMap.insert(
 163                                                                                         std::pair<std::string, std::string>(
 164                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_PRIORITY,         "isHighPriority"));
 165                         attributeMap.insert(
 166                                                                                         std::pair<std::string, std::string>(
 167                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_SUBJECT,          "subject"));
 168                         attributeMap.insert(
 169                                                                                         std::pair<std::string, std::string>(
 170                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_ATTACHMENT,    "attachment_count"));
 171                         attributeMap.insert(
 172                                                                                         std::pair<std::string, std::string>(
 173                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TYPE,             "type"));
 174
 175                         attributeMap.insert(
 176                                                                                         std::pair<std::string, std::string>(
 177                                                                                                         ConversationFilterValidatorFactory::ATTRIBUTE_MESSAGE_COUNT,  "thread_item_count"));
 178                 }
 179
 180                 void MessageQueryGenerator::setSmsMmsAttributeMap(){
 181                         LogDebug("<<<");
 182                         attributeMap.clear();
 183
 184                         attributeMap.insert(
 185                                                                                                                 std::pair<std::string, std::string>(
 186                                                                                                                                 MessageFilterValidatorFactory::ATTRIBUTE_ID,          "A.MSG_ID"));
 187                         attributeMap.insert(
 188                                                                                         std::pair<std::string, std::string>(
 189                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_FOLDER,          "A.FOLDER_ID"));
 190                         attributeMap.insert(
 191                                                                                         std::pair<std::string, std::string>(
 192                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP,       "A.DISPLAY_TIME"));
 193 //TODO check sms mms attribute frome, to, cc, bcc
 194                                                 attributeMap.insert(
 195                                                                                         std::pair<std::string, std::string>(
 196                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_FROM,            "B.ADDRESS_VAL"));
 197                         attributeMap.insert(
 198                                                                                         std::pair<std::string, std::string>(
 199                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TO,              "B.ADDRESS_VAL"));
 200 //                      attributeMap.insert(
 201 //                                                                                      std::pair<std::string, std::string>(
 202 //                                                                                                      MessageFilterValidatorFactory::ATTRIBUTE_CC,              "full_address_cc"));
 203 //                      attributeMap.insert(
 204 //                                                                                      std::pair<std::string, std::string>(
 205 //                                                                                                      MessageFilterValidatorFactory::ATTRIBUTE_BCC,             "full_address_bcc"));
 206                         attributeMap.insert(
 207                                                                                         std::pair<std::string, std::string>(
 208                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_BODY,            "A.MSG_TEXT"));
 209                         attributeMap.insert(
 210                                                                                         std::pair<std::string, std::string>(
 211                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_IS_READ,          "A.READ_STATUS"));   //TODO 1:seen, 2:deleted, 4:flagged, 8:answered, 20:draft
 212                         attributeMap.insert(
 213                                                                                         std::pair<std::string, std::string>(
 214                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_PRIORITY,         "A.PRIORITY"));
 215                         attributeMap.insert(
 216                                                                                         std::pair<std::string, std::string>(
 217                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_SUBJECT,          "A.SUBJECT"));
 218                         attributeMap.insert(
 219                                                                                         std::pair<std::string, std::string>(
 220                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_ATTACHMENT,    "A.ATTACHMENT_COUNT"));
 221                         attributeMap.insert(
 222                                                                                         std::pair<std::string, std::string>(
 223                                                                                                         MessageFilterValidatorFactory::ATTRIBUTE_TYPE,             "A.MAIN_TYPE"));
 224
 225                         LogDebug(">>");
 226                 }
 227
 228                 void MessageQueryGenerator::initAttributeMap(){
 229                         switch (m_mode){
 230                                 case MODE_EMAIL:
 231                                         LogDebug("MODE_EMAIL");
 232                                         setEmailAttributeMap();
 233                                         break;
 234                                 case MODE_SMS:
 235                                 case MODE_MMS:
 236                                         LogDebug("MODE_SMS or MODE_MMS");
 237                                         setSmsMmsAttributeMap();
 238                                         break;
 239                                 default: //TODO throw exception
 240                                         ;
 241                         }
 242                 }
 243
 244                 void MessageQueryGenerator::visitPreComposite(Api::Tizen::FilterType& type, int depth){
 245                         LogDebug("<<<");
 246                         m_queryVector.push_back("(");
 247                         LogDebug("getServiceType = " << getServiceType());
 248                         LogDebug(">>>");
 249                 }
 250
 251                 void MessageQueryGenerator::visitInComposite(Api::Tizen::FilterType& type, int depth){
 252                         LogDebug("<<<");
 253
 254                         if(m_typeProcessing == 1){
 255                                 m_typeProcessing = 0;
 256
 257                                 if(type != INTERSECTION_FILTER){
 258                                         LogError("[ERROR] >>> invalid Filter type:" << type);
 259                                         ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
 260                                 }
 261
 262                                 LogDebug(">>>");
 263                                 if(m_mode == MODE_EMAIL)
 264                                 {
 265                                         return;
 266                                 }
 267                         }
 268
 269                         if(type == INTERSECTION_FILTER){
 270                                 m_queryVector.push_back("AND");
 271                         }
 272 //                      else if(type == UNION_FILTER){
 273 //                              m_queryVector.push_back("OR");
 274 //                      }
 275                         else{
 276                                 LogError("[ERROR] invalid Filter type:" << type);
 277                                 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
 278                         }
 279
 280                         LogDebug(">>>");
 281                 }
 282
 283                 void MessageQueryGenerator::visitPostComposite(Api::Tizen::FilterType& type, int depth){
 284                         LogDebug("<<<");
 285                         if(m_typeProcessing == 1){
 286                                 m_typeProcessing = 0;
 287                                 if(m_mode == MODE_EMAIL)
 288                                 {
 289                                         m_queryVector.erase(m_queryVector.end());
 290                                 }
 291                         }else{
 292                         }
 293
 294                         m_queryVector.push_back(")");
 295                         LogDebug(">>>");
 296                 }
 297
 298                 std::string MessageQueryGenerator::convertToEmfAttrName(std::string attrName){
 299                         LogDebug("<<< attrName:[" << attrName << "]");
 300
 301                         std::string retString;
 302
 303                         std::map<std::string, std::string>::iterator it = attributeMap.find(attrName);
 304                         if(it == attributeMap.end()){
 305                                 MsgLogWanning("[WANNING] attribute not found : ["<< attrName << "]");
 306                         }else{
 307                                 retString = static_cast<std::string>(attributeMap.find(attrName)->second);
 308                         }
 309
 310                         LogDebug(">> retString:[" << retString << "]");
 311                         return retString;
 312                 }
 313
 314                 std::string MessageQueryGenerator::createTimeString(std::string& timeString)
 315                 {
 316                         LogDebug("<<< timeString:[" << timeString << "]");
 317
 318                         size_t pos = timeString.find("-",0);
 319                         while(pos!= std::string::npos){
 320                                 timeString.erase(pos,1);
 321                                 pos = timeString.find('-',0);
 322                         }
 323
 324                         LogDebug(">>> timeString:[" << timeString << "]");
 325                         return timeString;
 326                 }
 327
 328                 std::string MessageQueryGenerator::createFolderType(std::string& value)
 329                 {
 330                         LogDebug("<<< value:[" << value << "]");
 331                         std::string retFolderType;
 332                         std::ostringstream outstream;
 333
 334                         if(value.compare("1") == 0){
 335                                 LogDebug("<<< value:[INBOX]");
 336                                 outstream << MSG_INBOX_ID;
 337                         }else if(value.compare("2") == 0){
 338                                 LogDebug("<<< value:[OUTBOX]");
 339                                 outstream << MSG_OUTBOX_ID;
 340                         }else if(value.compare("3") == 0){
 341                                 LogDebug("<<< value:[DRAFTBOX]");
 342                                 outstream << MSG_DRAFT_ID;
 343                         }else if(value.compare("4") == 0){
 344                                 LogDebug("<<< value:[SENTBOX]");
 345                                 outstream << MSG_SENTBOX_ID;
 346                         }else{
 347                                 LogDebug("[ERROR] unsupported type:["<< value << "]");
 348                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid folder id");
 349                         }
 350
 351                         retFolderType = outstream.str();
 352
 353                         LogDebug(">>> retFolderType:[" << retFolderType << "]");
 354                         return retFolderType;
 355                 }
 356
 357                 std::string MessageQueryGenerator::createPriorityTypeForEmail(std::string& value)
 358                 {
 359                         LogDebug("<<< value:[" << value << "]");
 360                         std::string retPriorityType;
 361
 362                         if(value.compare("true")==0){
 363                                 retPriorityType = "1";
 364                         }else{
 365                                 retPriorityType = "3 OR priority=5";
 366                         }
 367
 368                         return retPriorityType;
 369                 }
 370
 371                 std::string MessageQueryGenerator::createPriorityTypeForSmsMms(std::string& value){
 372                         LogDebug("<<< value:[" << value << "]");
 373                         std::string retPriorityType;
 374
 375                         if(value.compare("true")==0){
 376                                 retPriorityType = "1";
 377                         }else if(value.compare("false")==0){
 378                                 retPriorityType = "0";
 379                         }else{
 380                                 LogError(">>> invalid value:[" << value << "]");
 381                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "unsupported value");
 382                         }
 383
 384                         return retPriorityType;
 385                 }
 386
 387
 388                 std::string MessageQueryGenerator::convertToTimeFormat(const std::string& timeString){
 389                         LogDebug("<<< timeString:[" << timeString << "]");
 390
 391                         std::string retString;
 392                         retString.append("'");
 393
 394                         int yearLength = 4;
 395                         int nextStart = 0;
 396                         retString.append(timeString.substr(0, yearLength));
 397                         retString.append("-");
 398                         nextStart = nextStart + yearLength;
 399
 400                         int monthLength = 2;
 401                         retString.append(timeString.substr(nextStart, monthLength));
 402                         retString.append("-");
 403                         nextStart = nextStart + monthLength;
 404
 405                         int dateLength = 2;
 406                         retString.append(timeString.substr(nextStart, dateLength));
 407                         retString.append(" ");
 408                         nextStart = nextStart + dateLength;
 409
 410                         int hourLength = 2;
 411                         retString.append(timeString.substr(nextStart, hourLength));
 412                         retString.append(":");
 413                         nextStart = nextStart + hourLength;
 414
 415                         int minuteLength = 2;
 416                         retString.append(timeString.substr(nextStart, minuteLength));
 417                         retString.append(":");
 418                         nextStart = nextStart + minuteLength;
 419
 420                         int secondLength = 2;
 421                         retString.append(timeString.substr(nextStart, secondLength));
 422                         retString.append("'");
 423
 424                         LogDebug(">>> retString:[" << retString << "]");
 425                         return retString;
 426                 }
 427
 428                 //convert from '20111115000000' to 2011-11-15 00:00:00
 429                 std::string MessageQueryGenerator::createDateTimeTypeForSmsMms(Api::Tizen::AnyPtr& value){
 430                         std::string initialValueStr;
 431                         LogDebug("<<< value:[" << value->toString() << "]");
 432
 433                         if (!value->isNullOrUndefined()) {
 434                                 if( TizenApis::Api::Tizen::PrimitiveType_Time==value->getType() ) {
 435                                         LogDebug("<<<initialValue->getType()[" << value->getType() <<"]");
 436                                         tm date = value->getDateTm();
 437                                         initialValueStr = toDateDbStr(date);
 438                                         LogDebug("<<<valueStr[" << initialValueStr <<"]");
 439                                 }
 440                                 else {
 441                                         LogError("initialValue->getType() : [" << value->getType() << "]");
 442                                         ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid value Type");
 443                                 }
 444                         }
 445
 446                         std::string tmpValueString = initialValueStr;
 447                         std::string secondsSinceType;
 448                         secondsSinceType.append("strftime('%s', ");                     //SQL time format function
 449                         if(m_mode == MODE_SMS || m_mode == MODE_MMS ){
 450                                 tmpValueString = convertToTimeFormat(tmpValueString);
 451                         }
 452
 453                         secondsSinceType.append(tmpValueString);
 454                         secondsSinceType.append(")");
 455
 456                         LogDebug(">>> retPriorityType:[" << secondsSinceType << "]");
 457                         return secondsSinceType;
 458                 }
 459
 460                 std::string MessageQueryGenerator::createDateTimeTypeForSmsMms(std::string& timeString){
 461                         LogDebug("<<< value:[" << timeString << "]");
 462
 463                         std::string tmpValueString;
 464                         std::string secondsSinceType;
 465                         secondsSinceType.append("strftime('%s', ");                     //SQL time format function
 466                         if(m_mode == MODE_SMS || m_mode == MODE_MMS ){
 467                                 tmpValueString = convertToTimeFormat(timeString);
 468                         }
 469
 470                         secondsSinceType.append(tmpValueString);
 471                         secondsSinceType.append(")");
 472
 473                         LogDebug(">>> retPriorityType:[" << secondsSinceType << "]");
 474                         return secondsSinceType;
 475                 }
 476
 477                 std::string MessageQueryGenerator::createDateTimeTypeForEmail(Api::Tizen::AnyPtr& value)
 478                 {
 479                         std::string initialValueStr;
 480                         LogDebug("<<< value:[" << value->toString() << "]");
 481
 482                         if(value->getType() != PrimitiveType_Time){
 483                                 LogError("[ERROR]>> invalid type");
 484                                 return NULL;
 485                         }
 486
 487                         if (!value->isNullOrUndefined()) {
 488                                 if( TizenApis::Api::Tizen::PrimitiveType_Time==value->getType() ) {
 489                                         LogDebug("<<<initialValue->getType()[" << value->getType() <<"]");
 490                                         tm date = value->getDateTm();
 491                                         initialValueStr = toDateDbStr(date);
 492                                         LogDebug("<<<valueStr[" << initialValueStr <<"]");
 493                                 }
 494                                 else {
 495                                         LogError("initialValue->getType() : [" << value->getType() << "]");
 496                                         ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid value Type");
 497                                 }
 498                         }
 499                         return initialValueStr;
 500                 }
 501
 502                 std::string MessageQueryGenerator::toDateDbStr(const tm &date) const
 503                 {
 504                         stringstream ss;
 505                         ss << setfill('0') << setiosflags(ios::right) << setw(4) << (date.tm_year + 1900);
 506                         ss << setfill('0') << setiosflags(ios::right) << setw(2) << (date.tm_mon + 1);
 507                         ss << setfill('0') << setiosflags(ios::right) << setw(2) << date.tm_mday;
 508                         ss << setfill('0') << setiosflags(ios::right) << setw(2) << date.tm_hour;
 509                         ss << setfill('0') << setiosflags(ios::right) << setw(2) << date.tm_min;
 510                         ss << setfill('0') << setiosflags(ios::right) << setw(2) << date.tm_sec;
 511                         return ss.str();
 512                 }
 513
 514                 std::string MessageQueryGenerator::convertBooleanStringToIntegerString(std::string& booleanString){
 515                         std::string retString;
 516
 517                         if(booleanString.compare("true") == 0){
 518                                 retString = "1";
 519                         }else if(booleanString.compare("false") == 0){
 520                                 retString = "0";
 521                         }else{
 522                                 LogError("invalid booleanString:[" << booleanString << "]");
 523                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid booleanString :[" + booleanString + "]");
 524                         }
 525                         return retString;
 526                 }
 527
 528                 std::string MessageQueryGenerator::getMatchExactlyClause(std::string& attrName, Api::Tizen::AnyPtr& value)
 529                 {
 530                         std::string retClause;
 531                         std::string valueString = value->toString();
 532                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 533
 534                         do{
 535                                 if(m_mode == MODE_EMAIL){
 536                                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 537                                                 retClause = emfAttributeName + " LIKE '%%<" + valueString +">'";
 538                                                 break;
 539                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP)==0){
 540                                                 retClause = emfAttributeName + "=" + createDateTimeTypeForEmail(value);
 541                                                 break;
 542                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_PRIORITY)==0){
 543                                                 retClause = emfAttributeName + "=" + createPriorityTypeForEmail(valueString);
 544                                                 break;
 545                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_SERVICE_ID)==0){
 546                                                 retClause = emfAttributeName + "=" + valueString;
 547                                                 break;
 548                                         } else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FOLDER)==0) {
 549                                                 retClause = emfAttributeName + "=" + valueString;
 550                                                 break;
 551                                         }
 552                                 }else if(m_mode == MODE_SMS || m_mode == MODE_MMS ){
 553                                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 554                                                 retClause = "("+emfAttributeName + " ='"+ valueString + "' AND " + getMessageDirectionString() + "=1)";
 555                                                 break;
 556                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TO)==0){
 557                                                 retClause = "("+emfAttributeName + " ='"+ valueString + "' AND " + getMessageDirectionString() + "=0)";
 558                                                 break;
 559                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP)==0){
 560                                                 retClause = emfAttributeName + "=" + createDateTimeTypeForSmsMms(value); //TODO need to check
 561                                                 break;
 562                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_PRIORITY)==0){
 563                                                 retClause = emfAttributeName + "=" + createPriorityTypeForSmsMms(valueString);
 564                                                 break;
 565                                         } else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FOLDER)==0) {
 566                                                 retClause = emfAttributeName + "=" + createFolderType(valueString);
 567                                                 break;
 568                                         } else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TYPE)==0) {
 569                                                 retClause = emfAttributeName + "=" + convertMessageTypeToString(valueString);
 570                                                 break;
 571                                         }
 572
 573                                 }
 574
 575                                 if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_IS_READ)==0) {
 576                                         retClause = emfAttributeName + "=" + convertBooleanStringToIntegerString(valueString);
 577                                 } else if (attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_ATTACHMENT) == 0 ) {
 578                                         if(valueString.compare("true") == 0){
 579                                                 retClause = emfAttributeName + " > 0" ;
 580                                         } else {
 581                                                 retClause = emfAttributeName + " = 0" ;
 582                                         }
 583                                 } else {
 584                                         retClause = emfAttributeName + " = '" + value->toString() + "'"; //TODO need to check
 585                                 }
 586                         }while(false);
 587
 588                         return retClause;
 589                 }
 590
 591                 std::string MessageQueryGenerator::getMatchStartsWithClause(std::string& attrName, TizenApis::Api::Tizen::AnyPtr& value){
 592                         std::string retClause;
 593                         std::string valueString = value->toString();
 594                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 595
 596                         do{
 597                                 if(m_mode == MODE_EMAIL){
 598                                 }else if(m_mode == MODE_SMS || m_mode == MODE_MMS){
 599                                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 600                                                 retClause.append("(" + emfAttributeName + " LIKE '" + value->toString() +
 601                                                                 "%%' AND " + getMessageDirectionString() + "=1) ");
 602                                                 break;
 603                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TO)==0){
 604                                                 retClause.append("(" + emfAttributeName + " LIKE '" + value->toString() +
 605                                                                 "%%' AND " + getMessageDirectionString() +"=0) ");
 606                                                 break;
 607                                         }
 608                                 }
 609
 610                                 retClause.append(emfAttributeName + " LIKE '" + value->toString() +"%%'");
 611                         }while(false);
 612
 613                         return retClause;
 614                 }
 615
 616                 std::string MessageQueryGenerator::getMessageDirectionString(){
 617                         return MessageQueryGenerator::STRING_DIRECTION;
 618                 }
 619
 620                 std::string MessageQueryGenerator::getMatchEndsWithClause(std::string& attrName, TizenApis::Api::Tizen::AnyPtr& value){
 621                         std::string retClause;
 622                         std::string valueString = value->toString();
 623                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 624
 625                         do{
 626                                 if(m_mode == MODE_EMAIL){
 627                                 }else if(m_mode == MODE_SMS || m_mode == MODE_MMS){
 628                                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 629                                                 retClause.append("(" + emfAttributeName + " LIKE '%%" + value->toString() +
 630                                                                 "' AND "+ getMessageDirectionString() + "=1) ");
 631                                                 break;
 632                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TO)==0){
 633                                                 retClause.append("(" + emfAttributeName + " LIKE '%%" + value->toString() +
 634                                                                 "' AND " + getMessageDirectionString() + "=0) ");
 635                                                 break;
 636                                         }
 637                                 }
 638
 639                                 retClause.append(emfAttributeName + " LIKE '%%" + value->toString() +"'");
 640                         }while(false);
 641
 642                         return retClause;
 643                 }
 644
 645                 std::string MessageQueryGenerator::getMatchContainsClause(std::string& attrName, TizenApis::Api::Tizen::AnyPtr& value){
 646                         std::string retClause;
 647                         std::string valueString = value->toString();
 648                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 649
 650                         do{
 651                                 if(m_mode == MODE_EMAIL){
 652                                 }else if(m_mode == MODE_SMS || m_mode == MODE_MMS){
 653                                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_FROM)==0){
 654                                                 retClause.append("(" + emfAttributeName + " LIKE '%%" + value->toString() +
 655                                                                 "%%' AND " + getMessageDirectionString() + "=1) ");
 656                                                 break;
 657                                         }else if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TO)==0){
 658                                                 retClause.append("(" + emfAttributeName + " LIKE '%%" + value->toString() +
 659                                                                 "%%' AND " + getMessageDirectionString() + "=0) ");
 660                                                 break;
 661                                         }
 662                                 }
 663
 664                                 retClause.append(emfAttributeName + " LIKE '%%" + value->toString() +"%%'");
 665                         }while(false);
 666
 667                         return retClause;
 668                 }
 669
 670                 void MessageQueryGenerator::visitAttribute(std::string& attrName, Api::Tizen::MatchFlag& matchFlag,
 671                                 Api::Tizen::AnyPtr& matchValue, int depth){
 672                         LogDebug("<<< attrName:[" << attrName << "], matchFlag:[" << matchFlag << "]");
 673
 674                         if(matchValue == NULL)
 675                                 return;
 676
 677                         LogDebug("matchValue:" << matchValue->toString());
 678
 679                         visitAttributeEach(attrName, matchFlag, matchValue, depth);
 680
 681                         LogDebug(">>>");
 682                 }
 683
 684                 int MessageQueryGenerator::convertMessageType(std::string& stringType){
 685                         LogDebug("<<< stringType:[" << stringType << "]");
 686
 687                         int retMessageType = -1;
 688
 689                         if(stringType.compare("messaging.sms") ==0){
 690                                 retMessageType = Api::Messaging::SMS;
 691                         }else if(stringType.compare("messaging.mms") ==0){
 692                                 retMessageType = Api::Messaging::MMS;
 693                         }else if(stringType.compare("messaging.email") ==0){
 694                                 retMessageType = Api::Messaging::EMAIL;
 695                         }else{
 696                                 MsgLogError("invalid type:[" << stringType << "]");
 697                                 return -1;
 698                         }
 699
 700                         LogDebug(">>> retMessageType:" << retMessageType);
 701                         return retMessageType;
 702                 }
 703
 704
 705                 std::string MessageQueryGenerator::convertMessageTypeToString(std::string& stringType){
 706                         LogDebug("<<< value:[" << stringType << "]");
 707                         std::string retMessageType;
 708                         std::ostringstream outstream;
 709
 710                         if(stringType.compare("messaging.sms") ==0){
 711                                 outstream << Api::Messaging::SMS;
 712                         }else if(stringType.compare("messaging.mms") ==0){
 713                                 outstream << Api::Messaging::MMS;
 714                         }else if(stringType.compare("messaging.email") ==0){
 715                                 outstream << Api::Messaging::EMAIL;
 716                         }else{
 717                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid msg type");
 718                         }
 719
 720                         retMessageType = outstream.str();
 721
 722                         return retMessageType;
 723                 }
 724
 725                 void MessageQueryGenerator::visitAttributeEach(std::string& attrName, Api::Tizen::MatchFlag& matchFlag, Api::Tizen::AnyPtr& value, int depth){
 726                         LogDebug("<<< attrName:[" << attrName << "], value:[" << value->toString() << "]");
 727
 728                         if(attrName.compare("type")==0){
 729                                 m_typeProcessing = 1;
 730                                 m_currentType = value->toString();
 731
 732                                 m_messageType = convertMessageType(m_currentType);
 733                                 if(m_messageType == Api::Messaging::EMAIL)
 734                                 {
 735                                         LogDebug(">>> skip type");
 736                                         return;
 737                                 }
 738                         }
 739
 740                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 741
 742 //                      if(emfAttributeName == NULL){
 743 //                              LogDebug(">>> emfAttributeName is NULL");
 744 //                              return;
 745 //                      }
 746                         std::string tmpStringBuffer;
 747
 748                         if(matchFlag == Api::Tizen::MATCH_EXACTLY){
 749                                 LogDebug("STRING_MATCH_EXACTLY");
 750                                 tmpStringBuffer.append(getMatchExactlyClause(attrName, value));
 751                         }else if(matchFlag == Api::Tizen::MATCH_CONTAINS){
 752                                 LogDebug("STRING_MATCH_CONTAINS");
 753                                 tmpStringBuffer.append(getMatchContainsClause(attrName, value));
 754                         }else if(matchFlag == Api::Tizen::MATCH_STARTSWITH){
 755                                 LogDebug("STRING_MATCH_STARTSWITH");
 756                                 tmpStringBuffer.append(getMatchStartsWithClause(attrName, value));
 757                         }else if(matchFlag == Api::Tizen::MATCH_ENDSWITH){
 758                                 LogDebug("STRING_MATCH_ENDSWITH");
 759                                 tmpStringBuffer.append(getMatchEndsWithClause(attrName, value));
 760                         }else{
 761                                 LogDebug("[ERROR]invalid match flag[" << matchFlag << "]");
 762                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid match flag:[" << matchFlag << "]");
 763                         }
 764 //                              else if(iter->find(MATCH_CASESENSITIVE)){               //TODO check case sensitive
 765 //                              }
 766                         m_queryVector.push_back(tmpStringBuffer);
 767                         LogDebug(">>>");
 768                 }
 769
 770                 void MessageQueryGenerator::visitAttributeRange(std::string& attrName, Api::Tizen::AnyPtr& initialValue, Api::Tizen::AnyPtr& endValue, int depth) {
 771                         LogDebug("<<< sttrName:[" << attrName <<"]");
 772
 773                         string initialValueStr;
 774                         string endValueStr;
 775
 776                         if(initialValue == NULL || endValue == NULL)
 777                                 return;
 778
 779                         std::string tmpStringBuffer;
 780
 781                         std::string emfAttributeName = convertToEmfAttrName(attrName);
 782                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP)==0){
 783
 784                                 if (!initialValue->isNullOrUndefined()) {
 785                                         if( TizenApis::Api::Tizen::PrimitiveType_Time==initialValue->getType() ) {
 786                                                 LogDebug("<<<initialValue->getType()[" << initialValue->getType() <<"]");
 787                                                 tm date = initialValue->getDateTm();
 788                                                 initialValueStr = toDateDbStr(date);
 789                                                 LogDebug("<<<valueStr[" << initialValueStr <<"]");
 790                                         }
 791                                         else {
 792                                                 LogError("initialValue->getType() : [" << initialValue->getType() << "]");
 793                                                 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid initialValue Type");
 794                                         }
 795                                 }
 796
 797                                 if (!endValue->isNullOrUndefined()) {
 798                                         if( TizenApis::Api::Tizen::PrimitiveType_Time==endValue->getType() ) {
 799                                                 LogDebug("<<<initialValue->getType()[" << endValue->getType() <<"]");
 800                                                 tm date = endValue->getDateTm();
 801                                                 endValueStr = toDateDbStr(date);
 802                                         } else {
 803                                                 LogError("endValue->getType() : [" << endValue->getType() << "]");
 804                                                 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid endValue Type");
 805                                         }
 806                                 }
 807
 808
 809                                 if(m_mode == MODE_EMAIL){
 810                                         tmpStringBuffer.append(emfAttributeName + " BETWEEN " + initialValueStr + " AND " + endValueStr);
 811                                 }else if(m_mode == MODE_SMS || m_mode == MODE_MMS){
 812                                         tmpStringBuffer.append(emfAttributeName + " BETWEEN " +
 813                                                         createDateTimeTypeForSmsMms(initialValueStr) + " AND " +
 814                                                         createDateTimeTypeForSmsMms(endValueStr));
 815                                 }
 816                         }
 817
 818                         m_queryVector.push_back(tmpStringBuffer);
 819                         LogDebug(">>>");
 820                 }
 821
 822                 std::string MessageQueryGenerator::getQueryFromVector()
 823                 {
 824                         std::string retString;
 825
 826                         std::vector<string>::const_iterator it = m_queryVector.begin();
 827                         while(it != m_queryVector.end()){
 828                                 retString.append(*it);
 829                                 retString.append(" ");
 830                                 it++;
 831                         }
 832
 833                         LogDebug(">>> retString:" << retString);
 834                         return retString;
 835                 }
 836
 837                 std::string MessageQueryGenerator::getQuery(){
 838                         std::stringstream buffer;
 839
 840                         m_query.append(getQueryFromVector());
 841
 842                         if(m_query.compare(getQueryPrefix())==0){
 843                                 return "";
 844                         }else{
 845                                 if(m_sortMode != NULL){
 846                                         std::string platformAttrName = convertToEmfAttrName(m_sortMode->getAttributeName());
 847                                         std::string sortModeString;
 848                                         if(m_sortMode->getOrder() == ASCENDING_SORT_ORDER){
 849                                                 sortModeString = "ASC";
 850                                         }else{
 851                                                 sortModeString = "DESC";
 852                                         }
 853
 854                                         buffer << " ORDER BY " << platformAttrName << " " << sortModeString;
 855                                         if(m_limit != 0){
 856                                                 buffer << " LIMIT "  << m_offset  << "," << m_limit;
 857                                         }
 858                                 }
 859
 860                                 m_query.append(getQuerySuffix());
 861 //                              m_query.append(buffer.str());
 862                                 m_orderLimit.append(buffer.str());
 863                                 return m_query;
 864                         }
 865                 }
 866
 867                 std::string MessageQueryGenerator::getOrderLimit(){
 868                         return m_orderLimit;
 869                 }
 870
 871                 std::string MessageQueryGenerator::getQueryPrefix(){
 872                         return MessageQueryGenerator::STRING_WHERE;
 873                 }
 874
 875                 std::string MessageQueryGenerator::getQuerySuffix(){
 876                         return MessageQueryGenerator::STRING_SUFFIX;
 877                 }
 878
 879
 880
 881                 }
 882         }               //namespace Platform
 883 }               //namespace WrtPlugins