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