src/platform/Tizen/Call/CallHistoryFilter.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
  18 #include <dpl/log/log.h>
  19 #include <iomanip>
  20
  21 #include <API/Call/CallDefine.h>
  22 #include "CallHistoryFilter.h"
  23 #include "CallHistoryQuery.h"
  24
  25 using namespace std;
  26 using namespace TizenApis::Api::Tizen;
  27 using namespace TizenApis::Api::Call;
  28
  29 namespace {
  30 const std::string F_LOG_ID (STR_LOG_ID);
  31 const std::string F_LOG_TYPE (STR_LOG_TYPE);
  32 const std::string F_PERSON_ID (STR_PERSON_ID);
  33 const std::string F_NUMBER (STR_NUMBER);
  34 const std::string F_LOG_TIME (STR_LOG_TIME);
  35 const std::string F_DURATION (STR_DATA1);
  36 const std::string F_VOICE_ANSWERED ("1");
  37 const std::string F_VOICE_OUTGOING ("2");
  38 const std::string F_VOICE_MISSED_UNCHECKED ("5");
  39 const std::string F_VOICE_MISSED_CHECKED ("6");
  40 const std::string F_VOICE_REJECTED ("9");
  41 const std::string F_VOICE_BLOCKED ("11");
  42 const std::string F_VIDEO_ANSWERED ("3");
  43 const std::string F_VIDEO_OUTGOING ("4");
  44 const std::string F_VIDEO_MISSED_UNCHECKED ("7");
  45 const std::string F_VIDEO_MISSED_CHECKED ("8");
  46 const std::string F_VIDEO_REJECTED ("10");
  47 const std::string F_VIDEO_BLOCKED ("12");
  48 const std::string F_LEFT_BRACKET(" (");
  49 const std::string F_RIGHT_BRACKET(")");
  50 const std::string F_AND(" AND ");
  51 const std::string F_OR(" OR ");
  52 const std::string F_GREATER_THAN (">");
  53 const std::string F_LESS_THAN ("<");
  54 const std::string F_EQUAL ("=");
  55 const std::string F_S_QUOTATION ("'");
  56 }
  57 namespace TizenApis {
  58 namespace Platform {
  59 namespace Call {
  60
  61 CallHistoryFilter::CallHistoryFilter() : m_query("")
  62 {
  63         init();
  64 }
  65
  66 CallHistoryFilter::~CallHistoryFilter()
  67 {
  68 }
  69
  70 void CallHistoryFilter::visitPreComposite(FilterType& type, int depth)
  71 {
  72         m_query = m_query + F_LEFT_BRACKET;
  73 }
  74
  75 void CallHistoryFilter::visitInComposite(FilterType& type, int depth)
  76 {
  77         if(type == Api::Tizen::UNION_FILTER)
  78                 m_query = m_query + F_OR;
  79         else if(type == Api::Tizen::INTERSECTION_FILTER)
  80                 m_query = m_query + F_AND;
  81 }
  82
  83 void CallHistoryFilter::visitPostComposite(FilterType& type, int depth)
  84 {
  85         m_query = m_query + F_RIGHT_BRACKET;
  86 }
  87
  88 void CallHistoryFilter::visitAttribute(std::string& attrName, MatchFlag& matchFlag, Api::Tizen::AnyPtr& matchValue, int depth)
  89 {
  90         std::string str ("");
  91
  92         if (matchValue == NULL) {
  93                 return;
  94         }
  95
  96         str.append(convertAttribute(attrName, matchValue));
  97
  98         m_query = m_query + str;
  99 }
 100
 101 void CallHistoryFilter::visitAttributeRange(std::string& attrName, AnyPtr& initialValue, AnyPtr& endValue, int depth)
 102 {
 103         if(initialValue == NULL || endValue == NULL)
 104                 return;
 105
 106         string str ("");
 107         string name ("");
 108         string initialValueStr ("");
 109         string endValueStr ("");
 110
 111         if (attrName.compare(STR_RP_REMOTEPARTY) == 0) {
 112                 name = F_NUMBER;
 113         } else if (attrName.compare(STR_RP_CONTACTREF) == 0) {
 114                 name = F_PERSON_ID;
 115         } else if (attrName.compare(STR_START_TIME) == 0) {
 116                 name = F_LOG_TIME;
 117         } else if (attrName.compare(STR_DURATION) == 0) {
 118                 name = F_DURATION;
 119         } else if (attrName.compare(STR_ENTRY_ID) == 0) {
 120                 name = F_LOG_ID;
 121         } else {
 122                 name = attrName;
 123         }
 124
 125         if (!initialValue->isNullOrUndefined()) {
 126                 if(initialValue->getType() == PrimitiveType_Time) {
 127                         tm date = initialValue->getDateTm();
 128                         std::stringstream time;
 129                         time << mktime(&date);
 130                         initialValueStr = time.str();
 131                 } else {
 132                         initialValueStr = initialValue->toString();
 133                 }
 134         }
 135
 136         if (!endValue->isNullOrUndefined()) {
 137                 if(endValue->getType() == PrimitiveType_Time) {
 138                         tm date = endValue->getDateTm();
 139                         std::stringstream time;
 140                         time << mktime(&date);
 141                         endValueStr = time.str();
 142
 143                 } else {
 144                         endValueStr = endValue->toString();
 145                 }
 146         }
 147
 148         if (!initialValue->isNullOrUndefined() && endValue->isNullOrUndefined()) {
 149                 str = F_LEFT_BRACKET + name + F_GREATER_THAN + F_EQUAL + F_S_QUOTATION + initialValueStr + F_S_QUOTATION + F_RIGHT_BRACKET;
 150         } else if (initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 151                 str = F_LEFT_BRACKET + name + F_LESS_THAN + F_S_QUOTATION + endValueStr + F_S_QUOTATION + F_RIGHT_BRACKET;
 152         } else if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
 153                 str = F_LEFT_BRACKET + name + F_GREATER_THAN + F_EQUAL + F_S_QUOTATION + initialValueStr + F_S_QUOTATION + F_AND + name + F_LESS_THAN + F_S_QUOTATION + endValueStr + F_S_QUOTATION + F_RIGHT_BRACKET;
 154         }
 155
 156         m_query = m_query + str;
 157 }
 158
 159 void CallHistoryFilter::init()
 160 {
 161         m_query.clear();
 162         m_query.append(" WHERE");
 163 }
 164 std::string CallHistoryFilter::convertAttributeArray(std::string &name, AnyArrayPtr& values)
 165 {
 166         std::string query("");
 167         AnyArray::iterator it = values->begin();
 168         query.append(F_LEFT_BRACKET);
 169
 170         do {
 171                 if (it != values->begin()) {
 172                         query.append(F_OR);
 173                 }
 174                 query.append(convertAttribute(name, *it));
 175                 it++;
 176         } while(it != values->end());
 177
 178         query.append(F_RIGHT_BRACKET);
 179         return query;
 180 }
 181
 182 std::string CallHistoryFilter::convertAttribute(std::string &name, AnyPtr& value)
 183 {
 184         std::string query("");
 185         if (name.compare(STR_DIRECTION) == 0) {
 186                 if (value->toString().compare(STR_RECEIVED) == 0) {
 187                         query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_ANSWERED + F_OR
 188                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_ANSWERED + F_RIGHT_BRACKET;
 189                 } else if (value->toString().compare(STR_DIALED) == 0) {
 190                         query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_OUTGOING + F_OR
 191                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_OUTGOING + F_RIGHT_BRACKET;
 192                 } else if (value->toString().compare(STR_MISSED) == 0) {
 193                         query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_MISSED_CHECKED + F_OR
 194                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_MISSED_CHECKED + F_RIGHT_BRACKET;
 195                 } else if (value->toString().compare(STR_MISSED_NEW) == 0) {
 196                         query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_MISSED_UNCHECKED + F_OR
 197                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_MISSED_UNCHECKED + F_RIGHT_BRACKET;
 198                 } else if (value->toString().compare(STR_REJECTED) == 0) {
 199                         query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_REJECTED + F_OR
 200                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_REJECTED  + F_RIGHT_BRACKET;
 201                 } else if (value->toString().compare(STR_BLOCKED) == 0) {
 202                         query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_BLOCKED + F_OR
 203                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_BLOCKED + F_RIGHT_BRACKET;
 204                 } else {
 205                         query = F_LEFT_BRACKET + F_LOG_TYPE + "=0" + F_RIGHT_BRACKET;
 206                 }
 207         } else if (name.compare(STR_TAGS) == 0) {
 208                 if (value->toString().compare(STR_CALL) == 0) {
 209                         query = F_LEFT_BRACKET + F_LOG_TYPE + F_GREATER_THAN + F_EQUAL + F_VOICE_ANSWERED + F_AND
 210                                         + F_LOG_TYPE + F_LESS_THAN + F_EQUAL + F_VIDEO_BLOCKED + F_RIGHT_BRACKET;
 211                 } else if (value->toString().compare(STR_CALL_VOICE) == 0) {
 212                         query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_ANSWERED + F_OR
 213                                         + F_LOG_TYPE + F_EQUAL + F_VOICE_OUTGOING + F_OR
 214                                         + F_LOG_TYPE + F_EQUAL + F_VOICE_MISSED_UNCHECKED + F_OR
 215                                         + F_LOG_TYPE + F_EQUAL + F_VOICE_MISSED_CHECKED + F_OR
 216                                         + F_LOG_TYPE + F_EQUAL + F_VOICE_REJECTED + F_OR
 217                                         + F_LOG_TYPE + F_EQUAL + F_VOICE_BLOCKED + F_RIGHT_BRACKET;
 218                 } else if (value->toString().compare(STR_CALL_VIDEO) == 0) {
 219                         query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VIDEO_ANSWERED + F_OR
 220                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_OUTGOING + F_OR
 221                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_MISSED_UNCHECKED + F_OR
 222                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_MISSED_CHECKED + F_OR
 223                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_REJECTED + F_OR
 224                                         + F_LOG_TYPE + F_EQUAL + F_VIDEO_BLOCKED + F_RIGHT_BRACKET;
 225                 } else {
 226                         query = F_LEFT_BRACKET + F_LOG_TYPE + "=0" + F_RIGHT_BRACKET;
 227                 }
 228         } else if (name.compare(STR_RP_REMOTEPARTY) == 0) {
 229                 query = F_LEFT_BRACKET + F_NUMBER + F_EQUAL + F_S_QUOTATION + value->toString() + F_S_QUOTATION + F_RIGHT_BRACKET;
 230         } else if (name.compare(STR_RP_CONTACTREF) == 0) {
 231                 query = F_LEFT_BRACKET + F_PERSON_ID + F_EQUAL + F_S_QUOTATION + value->toString() + F_S_QUOTATION + F_RIGHT_BRACKET;
 232         } else if (name.compare(STR_START_TIME) == 0) {
 233                 std::string dateStr ("");
 234                 if(value->getType() == PrimitiveType_Time) {
 235                         tm date = value->getDateTm();
 236                         std::stringstream time;
 237                         time << mktime(&date);
 238                         dateStr = time.str();
 239                 } else {
 240                         return query;
 241                 }
 242                 query = F_LEFT_BRACKET + F_LOG_TIME + F_EQUAL + F_S_QUOTATION + dateStr + F_S_QUOTATION + F_RIGHT_BRACKET;
 243         } else if (name.compare(STR_DURATION) == 0) {
 244                 query = F_LEFT_BRACKET + F_DURATION + F_EQUAL + F_S_QUOTATION + value->toString() + F_S_QUOTATION + F_RIGHT_BRACKET;
 245         } else if (name.compare(STR_CALL_TYPE) == 0) {
 246                 if (value->toString().compare(STR_TIZEN_TEL) == 0) {
 247                         query = F_LEFT_BRACKET + F_LOG_TYPE + F_GREATER_THAN + F_EQUAL + F_VOICE_ANSWERED + F_AND
 248                                                 + F_LOG_TYPE + F_LESS_THAN + F_EQUAL + F_VIDEO_BLOCKED + F_RIGHT_BRACKET;
 249                 } else {
 250                         query = F_LEFT_BRACKET + F_LOG_TYPE + "=0" + F_RIGHT_BRACKET;
 251                 }
 252         } else if (name.compare(STR_ENTRY_ID) == 0) {
 253                 query = F_LEFT_BRACKET + F_LOG_ID + F_EQUAL + F_S_QUOTATION + value->toString() + F_S_QUOTATION + F_RIGHT_BRACKET;
 254         } else {
 255                 query = F_LEFT_BRACKET + F_LOG_TYPE + "=0" + F_RIGHT_BRACKET;
 256         }
 257
 258         return query;
 259 }
 260
 261 std::string CallHistoryFilter::getResult() const
 262 {
 263         return m_query;
 264 }
 265
 266 }
 267 }
 268 }