src/Messaging/StorageChangesFolderGenerator.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 "StorageChangesFolderGenerator.h"
  19 #include "StorageChangesFolderFilterValidatorFactory.h"
  20 #include "IMessagingTypes.h"
  21 #include <email-types.h>
  22 #include <Logger.h>
  23
  24 using namespace std;
  25 using namespace DeviceAPI::Tizen;
  26
  27 namespace DeviceAPI {
  28         namespace Messaging {
  29
  30
  31                 const int StorageChangesFolderGenerator::MESSAGE_TYPE_NOT_INITIALIZED = -1;
  32
  33                 StorageChangesFolderGenerator::StorageChangesFolderGenerator(IMessageFolderPtr folder):m_messageType(MESSAGE_TYPE_NOT_INITIALIZED) {
  34
  35                         m_id = folder->getId();
  36                         m_parentid = folder->getParentId();
  37                         m_accountid = folder->getAccountId();
  38                         m_contestType = (unsigned short)folder->getContentType();
  39                         m_name = folder->getName();
  40                         m_path = folder->getPath();
  41                         m_type = (unsigned short)folder->getType();
  42                         m_synchronizable = folder->getSynchronizable();
  43
  44                         LoggerD("m_type:" << m_type );
  45
  46                 }
  47
  48                 StorageChangesFolderGenerator::~StorageChangesFolderGenerator() {
  49                 }
  50
  51
  52                 void StorageChangesFolderGenerator::visitPreComposite(DeviceAPI::Tizen::FilterType& type, int depth){
  53                         LoggerD("<<<");
  54                         m_operand.push_back(leftblank);
  55                         LoggerD("Left_blank");
  56                         LoggerD(">>>");
  57                 }
  58
  59                 void StorageChangesFolderGenerator::visitInComposite(DeviceAPI::Tizen::FilterType& type, int depth){
  60                         LoggerD("<<<");
  61                         if(type ==  UNION_FILTER ){
  62                                 LoggerD("UNION_FILTER");
  63                                 m_operand.push_back(operandUnion);
  64                         }else if(type == INTERSECTION_FILTER){
  65                                 LoggerD("INTERSECTION_FILTER");
  66                                 m_operand.push_back(operandIntersection);
  67                         }else{
  68                                 LoggerE("[ERROR] invalid Filter type:" << type);
  69                         }
  70
  71                         LoggerD(">>>");
  72                 }
  73
  74                 void StorageChangesFolderGenerator::visitPostComposite(DeviceAPI::Tizen::FilterType& type, int depth){
  75                         LoggerD("<<<");
  76                         bool data1, data2;
  77                         do
  78                         {
  79                                 LoggerD("m_result size =" << m_result.size());
  80                                 data1 = m_result.back();
  81                                 m_result.pop_back();
  82                                 data2 = m_result.back();
  83                                 m_result.pop_back();
  84                                 LoggerD("m_result size =" << m_result.size());
  85                                 LoggerD("m_operand.back() =" << m_operand.back());
  86                                 LoggerD("m_operand size =" << m_operand.size());
  87                                 if(m_operand.back() == operandUnion)
  88                                 {
  89                                         LoggerD("Union");
  90                                         LoggerD("data1 = " << data1);
  91                                         LoggerD("data2 = " << data2);
  92                                         LoggerD("data1 || data2 = " << (data1 || data2));
  93                                         m_operand.pop_back();
  94                                         m_result.push_back(data1 || data2);
  95                                         LoggerD("result" << m_result.back());
  96                                         LoggerD("m_result size =" << m_result.size());
  97                                 }
  98                                 else if(m_operand.back() == operandIntersection)
  99                                 {
 100                                         LoggerD("Intersection");
 101                                         LoggerD("data1 = " << data1);
 102                                         LoggerD("data2 = " << data2);
 103                                         LoggerD("data1 && data2 = " << (data1 && data2));
 104                                         m_operand.pop_back();
 105                                         m_result.push_back(data1 && data2);
 106                                         LoggerD("result " << m_result.back());
 107                                         LoggerD("m_result size =" << m_result.size());
 108
 109                                 }
 110                         }while(m_operand.back() != leftblank);
 111                         m_operand.pop_back();
 112                         LoggerD("elase leftblank from m_operand");
 113                         LoggerD("m_operand size =" << m_operand.size());
 114                         LoggerD(">>>");
 115                 }
 116
 117                 bool StorageChangesFolderGenerator::getMatchExactlyClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
 118                 {
 119                         std::string valueString = value->toString();
 120                         LoggerD("<<< attrName : " << attrName);
 121                         LoggerD("<<< valueString : " << valueString);
 122                         LoggerD("<<< attrName.compare(valueString) : " << attrName.compare(valueString));
 123
 124                         if(attrName.compare(valueString) == 0)
 125                         {
 126                                 LoggerD("<<< getMatchExactlyClause SAME >>>");
 127                                 return TRUE;
 128                         }
 129                         else{
 130                                 LoggerD("<<< getMatchExactlyClause DIFF >>>");
 131                                 return FALSE;
 132                         }
 133                 }
 134
 135                 bool StorageChangesFolderGenerator::getMatchFullstringClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
 136                 {
 137                         std::string tempString1;
 138                         std::string tempString2;
 139
 140                         std::string valueString = value->toString();
 141                         LoggerD("<<< attrName : " << attrName);
 142                         LoggerD("<<< valueString : " << valueString);
 143
 144                         tempString1.assign(attrName);
 145                         tempString2.assign(valueString);
 146
 147                         StrLowChange(tempString1);
 148                         StrLowChange(tempString2);
 149
 150                         LoggerD("<<< attrName : " << tempString1);
 151                         LoggerD("<<< valueString : " << tempString2);
 152
 153                         if(tempString1.compare(tempString2) == 0)
 154                         {
 155                                 LoggerD("<<< getMatchFullstringClause SAME >>>");
 156                                 return TRUE;
 157                         }
 158                         else{
 159                                 LoggerD("<<< getMatchFullstringClause DIFF >>>");
 160                                 return FALSE;
 161                         }
 162                 }
 163
 164                 bool StorageChangesFolderGenerator::getMatchContainsClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
 165                 {
 166                         std::string tempString1;
 167                         std::string tempString2;
 168
 169                         std::string valueString = value->toString();
 170                         LoggerD("<<< attrName : " << attrName);
 171                         LoggerD("<<< valueString : " << valueString);
 172
 173                         tempString1.assign(attrName);
 174                         tempString2.assign(valueString);
 175
 176                         StrLowChange(tempString1);
 177                         StrLowChange(tempString2);
 178
 179                         LoggerD("<<< attrName : " << tempString1);
 180                         LoggerD("<<< valueString : " << tempString2);
 181
 182                         if(tempString1.find(tempString2) != std::string::npos)
 183                         {
 184                                 LoggerD("<<< getMatchContainsClause CONTAINS >>>");
 185                                 return TRUE;
 186                         }else{
 187                                 LoggerD("<<< getMatchContainsClause NOT CONTAINS >>>");
 188                                 return FALSE;
 189                         }
 190                 }
 191
 192                 bool StorageChangesFolderGenerator::getMatchStartwithClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
 193                 {
 194                         std::string tempString1;
 195                         std::string tempString2;
 196
 197                         std::string valueString = value->toString();
 198                         LoggerD("<<< attrName : " << attrName);
 199                         LoggerD("<<< valueString : " << valueString);
 200
 201                         tempString1.assign(attrName);
 202                         tempString2.assign(valueString);
 203
 204                         StrLowChange(tempString1);
 205                         StrLowChange(tempString2);
 206
 207                         LoggerD("<<< attrName : " << tempString1);
 208                         LoggerD("<<< valueString : " << tempString2);
 209
 210                         if(tempString1.size() < tempString2.size())
 211                                 return FALSE;
 212
 213                         if(tempString1.compare(0,tempString2.size(), tempString2) == 0)
 214                 {
 215                                 LoggerD("<<< getMatchStartwithClause START WITH >>>");
 216                                 return TRUE;
 217                         }
 218                         else{
 219                                 LoggerD("<<< getMatchStartwithClause NOT START WITH >>>");
 220                                 return FALSE;
 221                         }
 222                 }
 223
 224                 bool StorageChangesFolderGenerator::getMatchEndwithClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
 225                 {
 226                         std::string tempString1;
 227                         std::string tempString2;
 228
 229                         std::string valueString = value->toString();
 230                         LoggerD("<<< attrName : " << attrName);
 231                         LoggerD("<<< valueString : " << valueString);
 232
 233                         tempString1.assign(attrName);
 234                         tempString2.assign(valueString);
 235
 236                         StrLowChange(tempString1);
 237                         StrLowChange(tempString2);
 238
 239                         LoggerD("<<< attrName : " << tempString1);
 240                         LoggerD("<<< valueString : " << tempString2);
 241
 242                         if(tempString1.size() < tempString2.size())
 243                                 return FALSE;
 244
 245                         if(tempString1.compare(tempString1.size()-tempString2.size(),tempString2.size(), tempString2) == 0 )
 246                         {
 247                                 LoggerD("<<< getMatchEndwithClause END WITH >>>");
 248                                 return TRUE;
 249                         }
 250                         else{
 251                                 LoggerD("<<< getMatchEndwithClause NOT END WITH >>>");
 252                                 return FALSE;
 253                         }
 254                         }
 255
 256
 257                 bool StorageChangesFolderGenerator::getMatchExistClause(std::string& attrName)
 258                 {
 259                         LoggerD("<<< attrName : " << attrName);
 260                         if(attrName.size()> 0)
 261                                 return TRUE;
 262                         else
 263                                 return FALSE;
 264                 }
 265
 266                 void StorageChangesFolderGenerator::visitAttribute(std::string& attrName,
 267                                 DeviceAPI::Tizen::MatchFlag& matchFlag, DeviceAPI::Tizen::AnyPtr& matchValue, int depth){
 268                         LoggerD("<<< attrName:[" << attrName << "], matchFlag:[" << matchFlag << "]");
 269
 270                         if(matchFlag != DeviceAPI::Tizen::MATCH_EXISTS){
 271                                 if(matchValue == NULL)  {
 272                                 return;
 273                                 }
 274                         }
 275
 276                         LoggerD("matchValue:" << matchValue->toString());
 277
 278                         visitAttributeEach(attrName, matchFlag, matchValue, depth);
 279                 }
 280
 281                 void StorageChangesFolderGenerator::visitAttributeEach(std::string& attrName, DeviceAPI::Tizen::MatchFlag& matchFlag, DeviceAPI::Tizen::AnyPtr& value, int depth){
 282                         LoggerD("<<< attrName:[" << attrName << "], value:[" << value->toString() << "]");
 283                         std::string valueString;
 284
 285 //  Check Folder_type and filter_type
 286                         if(attrName.compare( StorageChangesFolderFilterValidatorFactory::ATTRIBUTE_ACCOUNT_ID)==0){
 287                                 LoggerD("<<< value:[" << value << "]");
 288                                 int nType = atoi(value->toString().c_str());
 289                                 if((int)m_accountid == nType)
 290                                 {
 291                                         m_result.push_back(TRUE);
 292                                         LoggerD("<<< accountid is same");
 293                                 }
 294                                 else
 295                                 {
 296                                         m_result.push_back(FALSE);
 297                                         LoggerD("<<< accountid is different");
 298                                 }
 299                                 return;
 300                         }
 301                         if(attrName.compare(StorageChangesFolderFilterValidatorFactory::ATTRIBUTE_CONTENT_TYPE)==0){
 302                         LoggerD("<<< value:[" << value << "]");
 303                                 std::string convertType = value->toString();
 304                                 int nType = convertMessageType(convertType);
 305                                 if((int)m_contestType == nType)
 306                                 {
 307                                         m_result.push_back(TRUE);
 308                                         LoggerD("<<< contestType is same");
 309                                 }
 310                                 else
 311                                 {
 312                                         m_result.push_back(FALSE);
 313                                         LoggerD("<<< contestType is different");
 314                                 }
 315                                 return;
 316                         }
 317                         if(attrName.compare(StorageChangesFolderFilterValidatorFactory::ATTRIBUTE_TYPE )==0){
 318                                 LoggerD("<<< value:[" << value << "]");
 319                                 std::string convertType = value->toString();
 320                                 int nType = convertFolderType(convertType);
 321                                 if((int)m_type == nType)
 322                                 {
 323                                         m_result.push_back(TRUE);
 324                                         LoggerD("<<< type is same");
 325                                 }
 326                                 else
 327                                 {
 328                                         m_result.push_back(FALSE);
 329                                         LoggerD("<<< type is different");
 330                                 }
 331                                 return;
 332                         }
 333                         if(attrName.compare(StorageChangesFolderFilterValidatorFactory::ATTRIBUTE_SYNCHRONIZABLE)==0){
 334                                 LoggerD("<<< value:[" << value << "]");
 335                                 std::string lowerString;
 336                                 lowerString.assign(value->toString());
 337                                 StrLowChange(lowerString);
 338                                 int nType = lowerString.compare("true");
 339                                 if((int)m_synchronizable != nType)
 340                                 {
 341                                         m_result.push_back(TRUE);
 342                                         LoggerD("<<< synchronizable is same");
 343                                 }
 344                                 else
 345                                 {
 346                                         m_result.push_back(FALSE);
 347                                         LoggerD("<<< synchronizable is different");
 348                                 }
 349                                 return;
 350                         }
 351
 352                         if(attrName.compare(StorageChangesFolderFilterValidatorFactory::ATTRIBUTE_NAME)==0){
 353                                 LoggerD("<<< value:[" << value << "]");
 354                                 LoggerD("<<< value->toString():[" << value->toString() << "]");
 355                                 LoggerD("<<< m_name:[" << m_name << "]");
 356
 357                                 valueString = m_name;
 358                                 if(getMatchFlagResult(value, valueString, matchFlag))
 359                                 {
 360                                         m_result.push_back(TRUE);
 361                                         LoggerD("<<< name is same");
 362                                 }
 363                                 else
 364                                 {
 365                                         m_result.push_back(FALSE);
 366                                         LoggerD("<<< name is different");
 367                                 }
 368                                 return;
 369                         }
 370
 371                         if(attrName.compare(StorageChangesFolderFilterValidatorFactory::ATTRIBUTE_PATH)==0){
 372                                 LoggerD("<<< value:[" << value << "]");
 373                                 LoggerD("<<< value->toString():[" << value->toString() << "]");
 374                                 LoggerD("<<< m_path:[" << m_path << "]");
 375
 376                                 valueString = m_path;
 377                                 if(getMatchFlagResult(value, valueString, matchFlag))
 378                                 {
 379                                         m_result.push_back(TRUE);
 380                                         LoggerD("<<< path is same");
 381                                 }
 382                                 else
 383                                 {
 384                                         m_result.push_back(FALSE);
 385                                         LoggerD("<<< path is different");
 386                                 }
 387                                 return;
 388                         }
 389
 390                         LoggerD(">>>");
 391                 }
 392
 393                 int StorageChangesFolderGenerator::convertMessageType(std::string& stringType){
 394                         LoggerD("<<< stringType:[" << stringType << "]");
 395
 396                         int retMessageType = -1;
 397
 398                         if(stringType.compare("messaging.sms") ==0){
 399                                 retMessageType = SMS;
 400                         }else if(stringType.compare("messaging.mms") ==0){
 401                                 retMessageType = MMS;
 402                         }else if(stringType.compare("messaging.email") ==0){
 403                                 retMessageType = EMAIL;
 404                         }else{
 405                                 LoggerE("invalid type:[" << stringType << "]");
 406                                 return -1;
 407                         }
 408
 409                         LoggerD(">>> retMessageType:" << retMessageType);
 410                         return retMessageType;
 411                 }
 412
 413                 int StorageChangesFolderGenerator::convertFolderType(std::string& stringType){
 414                         LoggerD("<<< stringType:[" << stringType << "]");
 415
 416                         int retMessageType = -1;
 417
 418                         if(stringType.compare("INBOX") ==0){
 419                                 retMessageType = INBOX;
 420                         }else if(stringType.compare("OUTBOX") ==0){
 421                                 retMessageType = OUTBOX;
 422                         }else if(stringType.compare("DRAFTBOX") ==0){
 423                                 retMessageType = DRAFTBOX;
 424                         }else if(stringType.compare("SENTBOX") ==0){
 425                                 retMessageType = SENTBOX;
 426                         }else{
 427                                 LoggerE("invalid type:[" << stringType << "]");
 428                                 return -1;
 429                         }
 430
 431                         LoggerD(">>> retMessageType:" << retMessageType);
 432                         return retMessageType;
 433                 }
 434
 435
 436                 void StorageChangesFolderGenerator::visitAttributeRange(std::string& attrName, DeviceAPI::Tizen::AnyPtr& initialValue, DeviceAPI::Tizen::AnyPtr& endValue, int depth) {
 437                         LoggerD("<<< NOT SUPPROTED");
 438                         LoggerD(">>>");
 439                         m_result.push_back(FALSE);
 440                 }
 441
 442                 bool StorageChangesFolderGenerator::getMatchFlagResult(DeviceAPI::Tizen::AnyPtr& value, std::string& valueString, DeviceAPI::Tizen::MatchFlag& matchFlag)
 443                 {
 444                         std::vector<std::string>::iterator iter;
 445                         bool result = FALSE;
 446                         if(matchFlag == DeviceAPI::Tizen::MATCH_EXACTLY){
 447                                 LoggerD("STRING_MATCH_EXACTLY");
 448                                 result = result || getMatchExactlyClause(valueString, value);
 449                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_FULLSTRING){
 450                                 LoggerD("STRING_MATCH_FULLSTRING");
 451                                 result = result || getMatchFullstringClause(valueString, value);
 452                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_CONTAINS){
 453                                 LoggerD("STRING_MATCH_CONTAINS");
 454                                 result = result || getMatchContainsClause(valueString, value);
 455                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_STARTSWITH){
 456                                 LoggerD("STRING_MATCH_STARTSWITH");
 457                                 result = result || getMatchStartwithClause(valueString, value);
 458                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_ENDSWITH){
 459                                 LoggerD("STRING_MATCH_ENDSWITH");
 460                                 result = result || getMatchEndwithClause(valueString, value);
 461                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_EXISTS){
 462                                 LoggerD("STRING_MATCH_EXIST");
 463                                 result = result || getMatchExistClause(valueString);
 464                         }else{
 465                                 LoggerD("[ERROR]invalid match flag : iter:" << *iter);
 466                         }
 467                         return result;
 468                 }
 469
 470                 bool StorageChangesFolderGenerator::getCompareResult()
 471                 {
 472                         bool result;
 473                         LoggerD("m_result.size() " << m_result.size());
 474                         result = m_result.back();
 475                         m_result.pop_back();
 476                         LoggerD("result = " << result);
 477                         return result;
 478                 }
 479
 480
 481                 void StorageChangesFolderGenerator::StrLowChange(std::string& tempString)
 482                 {
 483                         std::transform(tempString.begin(), tempString.end(), tempString.begin(), ::tolower);
 484                         return;
 485                 }
 486
 487         }
 488 }