src/Messaging/MessageQueryGenerator.cpp

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