src/Messaging/MessageFilterValidator.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 "MessageFilterValidator.h"
  19 #include "MessageFilterValidatorFactory.h"
  20 #include "log.h"
  21 #include <Logger.h>
  22
  23 using namespace DeviceAPI::Tizen;
  24
  25 namespace DeviceAPI {
  26         namespace Messaging {
  27
  28                 MessageFilterValidator::MessageFilterValidator(PropertyStructArray properties)
  29                                 :FilterValidator(properties){
  30                         m_isTypeSetted = false;
  31
  32                         initMatchFlagVectors();
  33                         initAttributeAndMatchFlagsMap();
  34                 }
  35
  36                 MessageFilterValidator::~MessageFilterValidator(){
  37                 }
  38
  39                 void MessageFilterValidator::initMatchFlagVectors(){
  40                         m_typeMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  41
  42                         m_idMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  43
  44                         m_serviceIdMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  45
  46                         m_folderIdMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  47
  48                         m_timestampMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  49
  50                         m_fromMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  51                         m_fromMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_CONTAINS);
  52                         m_fromMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_STARTSWITH);
  53                         m_fromMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_ENDSWITH);
  54
  55                         m_toMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  56                         m_toMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_CONTAINS);
  57                         m_toMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_STARTSWITH);
  58                         m_toMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_ENDSWITH);
  59
  60                         m_ccMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  61                         m_ccMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_CONTAINS);
  62                         m_ccMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_STARTSWITH);
  63                         m_ccMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_ENDSWITH);
  64
  65                         m_bccMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  66                         m_bccMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_CONTAINS);
  67                         m_bccMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_STARTSWITH);
  68                         m_bccMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_ENDSWITH);
  69
  70                         m_bodyMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  71                         m_bodyMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_CONTAINS);
  72
  73                         m_isReadMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  74
  75                         m_priorityMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  76
  77                         m_attachmentMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  78
  79                         m_subjectMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_EXACTLY);
  80                         m_subjectMatchFlagVec.push_back(MessageFilterValidatorFactory::MATCH_CONTAINS);
  81                 }
  82
  83                 void MessageFilterValidator::initAttributeAndMatchFlagsMap(){
  84                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_TYPE]      = m_typeMatchFlagVec;
  85                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_ID]        = m_idMatchFlagVec;
  86                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_SERVICE_ID]= m_serviceIdMatchFlagVec;
  87                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_FOLDER]    = m_folderIdMatchFlagVec;
  88                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP] = m_timestampMatchFlagVec;
  89                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_FROM]      = m_fromMatchFlagVec;
  90                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_CC]        = m_ccMatchFlagVec;
  91                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_BCC]       = m_bccMatchFlagVec;
  92                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_BODY]      = m_bodyMatchFlagVec;
  93                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_IS_READ]   = m_isReadMatchFlagVec;
  94                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_PRIORITY]  = m_priorityMatchFlagVec;
  95                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_SUBJECT]   = m_subjectMatchFlagVec;
  96                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_ATTACHMENT] = m_attachmentMatchFlagVec;
  97                         m_attributeAndMatchFlagsMap[MessageFilterValidatorFactory::ATTRIBUTE_TO]        = m_toMatchFlagVec;
  98                 }
  99
 100                 bool MessageFilterValidator::validateAttributeRange(std::string& attrName, DeviceAPI::Tizen::AnyPtr& initialValue, DeviceAPI::Tizen::AnyPtr& endValue, int depth){
 101                         if(initialValue == NULL || endValue == NULL)
 102                                 return false;
 103
 104                         bool retVal = false;
 105
 106                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TIMESTAMP)!=0){
 107                                 MsgLoggerE(">>> [ERROR] Not Supported attribute :[" << attrName << "]");
 108                                 return false;
 109                         }
 110
 111                         retVal = FilterValidator::validateAttributeRange(attrName, initialValue, endValue, depth);
 112                         return retVal;
 113                 }
 114
 115
 116                 bool MessageFilterValidator::vectorContains(std::vector<std::string>& vec, DeviceAPI::Tizen::MatchFlag& value){
 117                         std::string matchStr;
 118                         switch(value)
 119                         {
 120                         case DeviceAPI::Tizen::MATCH_EXACTLY:
 121                                 matchStr = "EXACTLY";
 122                                 break;
 123                         case DeviceAPI::Tizen::MATCH_FULLSTRING:
 124                                 matchStr = "FULLSTRING";
 125                                 break;
 126                         case DeviceAPI::Tizen::MATCH_CONTAINS:
 127                                 matchStr = "CONTAINS";
 128                                 break;
 129                         case DeviceAPI::Tizen::MATCH_STARTSWITH:
 130                                 matchStr = "STARTSWITH";
 131                                 break;
 132                         case DeviceAPI::Tizen::MATCH_ENDSWITH:
 133                                 matchStr = "ENDSWITH";
 134                                 break;
 135                         case DeviceAPI::Tizen::MATCH_EXISTS:
 136                                 matchStr = "EXISTS";
 137                                 break;
 138                         default:
 139                                 matchStr = "";
 140                                 break;
 141                         }
 142
 143                         std::vector<std::string>::iterator it;
 144                         for(it=vec.begin(); it<vec.end(); it++){
 145                                 if((*it).compare(matchStr) == 0){
 146                                         return true;
 147                                 }
 148                         }
 149
 150                         return false;
 151                 }
 152
 153                 bool MessageFilterValidator::validateAttribute(std::string& attrName, DeviceAPI::Tizen::MatchFlag& matchFlag,
 154                                 DeviceAPI::Tizen::AnyPtr& matchValue, int depth){
 155                         bool retBool = false;
 156
 157                         if(matchValue == NULL)
 158                                 return false;
 159
 160                         if(validateAttributeEach(attrName, matchFlag, matchValue, depth) == false){
 161                                 MsgLogWanning(">>>[Warning] attrName:[" << attrName << "] is invalid value:[" << matchValue->toString() << "]");
 162                                 return false;
 163                         }
 164
 165                         retBool = FilterValidator::validateAttribute(attrName, matchFlag, matchValue, depth);
 166                         LoggerD(">>> retBool:" << retBool);
 167                         return retBool;
 168                 }
 169
 170                 bool MessageFilterValidator::validateAttributeEach(std::string& attrName,MatchFlag& matchFlag, DeviceAPI::Tizen::AnyPtr& value, int depth){
 171                         LoggerD("<<< attrName:[" << attrName << "], value:[" << value->toString() << "]");
 172
 173                         if(attrName.compare(MessageFilterValidatorFactory::ATTRIBUTE_TYPE)==0){
 174                                 if(m_isTypeSetted == true){
 175                                         MsgLoggerE(">>> [ERROR] duplicated type :[" << attrName << "], value:[" <<
 176                                                         value->toString()<< "]");
 177                                         return false;
 178                                 }else{
 179                                         m_isTypeSetted = true;
 180                                 }
 181                         }
 182
 183                         if(m_attributeAndMatchFlagsMap.count(attrName) == 0)
 184                         {
 185                                 MsgLogWanning(">>>[Waning] attrName is not supported:[" << attrName << "]");
 186                                 return false;
 187                         }
 188
 189                         std::vector<std::string> vec = m_attributeAndMatchFlagsMap.find(attrName)->second;
 190
 191                         if(vectorContains(vec, matchFlag)==false){
 192                                 MsgLogWanning(">>>[Waning]MatchFlag check fail unsupported flag:[" << matchFlag << "] for Attribute:[" << attrName << "]");
 193                                 return false;
 194                         }
 195
 196                         LoggerD(">>> return true");
 197                         return true;
 198                 }
 199
 200         }       //namespace Messaging
 201 }