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