src/Messaging/FolderQueryGenerator.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 "FolderQueryGenerator.h"
  19 #include "FolderFilterValidatorFactory.h"
  20 #include "ConversationFilterValidatorFactory.h"
  21 #include "IMessagingTypes.h"
  22 #include "log.h"
  23 #include <Commons/Exception.h>
  24 #include <email-types.h>
  25 #include <Logger.h>
  26
  27 using namespace std;
  28 using namespace DeviceAPI::Tizen;
  29
  30 namespace DeviceAPI {
  31                 namespace Messaging {
  32
  33                 const std::string FolderQueryGenerator::STRING_MATCH_EXACTLY         = "EXACTLY";
  34                 const std::string FolderQueryGenerator::STRING_MATCH_CONTAINS        = "CONTAINS";
  35                 const std::string FolderQueryGenerator::STRING_MATCH_STARTSWITH      = "STARTSWITH";
  36                 const std::string FolderQueryGenerator::STRING_MATCH_ENDSWITH        = "ENDSWITH";
  37 //              const std::string FolderQueryGenerator::STRING_MATCH_CASESENSITIVE   = "CASESENSITIVE";
  38
  39                 const int FolderQueryGenerator::ACCOUNT_ID_NOT_INITIALIZED = -1;
  40
  41                 FolderQueryGenerator::FolderQueryGenerator():m_messageType(ACCOUNT_ID_NOT_INITIALIZED) {
  42                 }
  43
  44                 FolderQueryGenerator::~FolderQueryGenerator() {
  45                 }
  46
  47
  48                 void FolderQueryGenerator::visitPreComposite(DeviceAPI::Tizen::FilterType& type, int depth){
  49                         LoggerD("<<<");
  50                 }
  51
  52                 void FolderQueryGenerator::visitInComposite(DeviceAPI::Tizen::FilterType& type, int depth){
  53                         LoggerD("<<<");
  54
  55                         if(type != INTERSECTION_FILTER){
  56                                 LoggerE("[ERROR] >>> invalid Filter type:" << type);
  57                                 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
  58                                 return;
  59                         }
  60                 }
  61
  62                 void FolderQueryGenerator::visitPostComposite(DeviceAPI::Tizen::FilterType& type, int depth){
  63                         LoggerD("<<<");
  64                 }
  65
  66                 bool FolderQueryGenerator::getMatchExactlyClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
  67                 {
  68                         std::string retClause;
  69                         std::string valueString = value->toString();
  70
  71                         do{
  72                                 if(attrName.compare(FolderFilterValidatorFactory::ATTRIBUTE_ACCOUNTID)==0){
  73                                         m_accountId = atoi(value->toString().c_str());
  74                                         break;
  75                                 }else if(attrName.compare(FolderFilterValidatorFactory::ATTRIBUTE_FOLDERPATH)==0){
  76                                         m_folderPathProcessing = TRUE;
  77                                         m_folderpath = value->toString();
  78                                         break;
  79                                 }
  80                         }while(false);
  81
  82                         return FALSE;
  83                 }
  84
  85                 std::string FolderQueryGenerator::getMatchStartsWithClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value){
  86                         std::string retClause;
  87                         LoggerD("<<< NOT IMPLEMENTED YET");
  88                         return retClause;
  89                 }
  90
  91                 std::string FolderQueryGenerator::getMatchEndsWithClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value){
  92                         std::string retClause;
  93                         LoggerD("<<< NOT IMPLEMENTED YET");
  94                         return retClause;
  95                 }
  96
  97                 std::string FolderQueryGenerator::getMatchContainsClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value){
  98                         std::string retClause;
  99                         LoggerD("<<< NOT IMPLEMENTED YET");
 100                         return retClause;
 101                 }
 102
 103                 void FolderQueryGenerator::visitAttribute(std::string& attrName, DeviceAPI::Tizen::MatchFlag& matchFlag,
 104                                 DeviceAPI::Tizen::AnyPtr& matchValue, int depth){
 105                         LoggerD("<<< attrName:[" << attrName << "], matchFlag:[" << matchFlag << "]");
 106
 107                         if(matchValue == NULL)
 108                                 return;
 109
 110                         LoggerD("matchValue:" << matchValue->toString());
 111
 112                         visitAttributeEach(attrName, matchFlag, matchValue, depth);
 113
 114                         LoggerD(">>>");
 115                 }
 116
 117                 void FolderQueryGenerator::visitAttributeEach(std::string& attrName, DeviceAPI::Tizen::MatchFlag& matchFlag, DeviceAPI::Tizen::AnyPtr& value, int depth){
 118                         LoggerD("<<< attrName:[" << attrName << "], value:[" << value->toString() << "]");
 119
 120                         if(matchFlag == DeviceAPI::Tizen::MATCH_EXACTLY){
 121                                 LoggerD("STRING_MATCH_EXACTLY");
 122                                 getMatchExactlyClause(attrName, value);
 123                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_CONTAINS){
 124                                 LoggerD("STRING_MATCH_CONTAINS");
 125                                 getMatchContainsClause(attrName, value);
 126                         }else if(matchFlag== DeviceAPI::Tizen::MATCH_STARTSWITH){
 127                                 LoggerD("STRING_MATCH_STARTSWITH");
 128                                 getMatchStartsWithClause(attrName, value);
 129                         }else if(matchFlag == DeviceAPI::Tizen::MATCH_ENDSWITH){
 130                                 LoggerD("STRING_MATCH_ENDSWITH");
 131                                 getMatchEndsWithClause(attrName, value);
 132                         }else{
 133                                 LoggerD("[ERROR]invalid match flag[" << matchFlag << "]");
 134                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid match flag:[" << matchFlag << "]");
 135                         }
 136                         LoggerD(">>>");
 137                 }
 138
 139                 void FolderQueryGenerator::visitAttributeRange(std::string& attrName, DeviceAPI::Tizen::AnyPtr& initialValue, DeviceAPI::Tizen::AnyPtr& endValue, int depth) {
 140                         LoggerD("<<< NOT IMPLEMENTED YET");
 141                 }
 142
 143                 int FolderQueryGenerator::getAccountId()
 144                 {
 145                         return m_accountId;
 146                 }
 147
 148                 std::string FolderQueryGenerator::getFolderPath()
 149                 {
 150                         return m_folderpath;
 151                 }
 152
 153                 bool FolderQueryGenerator::isFolderPathExist()
 154                 {
 155                         LoggerE("m_folderPathProcessing : " << m_folderPathProcessing);
 156                         return m_folderPathProcessing;
 157                 }
 158
 159                 void FolderQueryGenerator::reset(){
 160                         m_folderPathProcessing = FALSE;
 161                         m_accountId = 0;
 162                         m_folderpath.clear();
 163                 }
 164
 165
 166         }
 167 }