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 "CallHistoryFilter.h"
  22 #include "CallHistoryQuery.h"
  23
  24 using namespace std;
  25 using namespace TizenApis::Api::Tizen;
  26 using namespace TizenApis::Api::Call;
  27
  28 namespace {
  29 const std::string STR_LOG_TYPE ("log_type");
  30 const std::string STR_CONTACT_ID ("contact_id");
  31 const std::string STR_NUMBER ("number");
  32 const std::string STR_LOG_TIME ("log_time");
  33 const std::string STR_DURATION ("data1");
  34 const std::string STR_VOICE_ANSWERED ("1");
  35 const std::string STR_VOICE_OUTGOING ("2");
  36 const std::string STR_VOICE_MISSED_UNCHECKED ("5");
  37 const std::string STR_VOICE_MISSED_CHECKED ("6");
  38 const std::string STR_VOICE_REJECTED ("9");
  39 const std::string STR_VOICE_BLOCKED ("11");
  40 const std::string STR_VIDEO_ANSWERED ("3");
  41 const std::string STR_VIDEO_OUTGOING ("4");
  42 const std::string STR_VIDEO_MISSED_UNCHECKED ("7");
  43 const std::string STR_VIDEO_MISSED_CHECKED ("8");
  44 const std::string STR_VIDEO_REJECTED ("10");
  45 const std::string STR_VIDEO_BLOCKED ("12");
  46 const std::string STR_LEFT_BRACKET(" (");
  47 const std::string STR_RIGHT_BRACKET(")");
  48 const std::string STR_AND(" AND ");
  49 const std::string STR_OR(" OR ");
  50 const std::string STR_GREATER_THAN (">");
  51 const std::string STR_LESS_THAN ("<");
  52 const std::string STR_EQUAL ("=");
  53 const std::string STR_S_QUOTATION ("'");
  54 }
  55 namespace TizenApis {
  56 namespace Platform {
  57 namespace Call {
  58
  59 CallHistoryFilter::CallHistoryFilter() : m_query("")
  60 {
  61         init();
  62 }
  63
  64 CallHistoryFilter::~CallHistoryFilter()
  65 {
  66 }
  67
  68 void CallHistoryFilter::visitPreComposite(FilterType& type, int depth)
  69 {
  70         m_query = m_query + STR_LEFT_BRACKET;
  71 }
  72
  73 void CallHistoryFilter::visitInComposite(FilterType& type, int depth)
  74 {
  75         if(type == Api::Tizen::UNION_FILTER)
  76                 m_query = m_query + STR_OR;
  77         else if(type == Api::Tizen::INTERSECTION_FILTER)
  78                 m_query = m_query + STR_AND;
  79 }
  80
  81 void CallHistoryFilter::visitPostComposite(FilterType& type, int depth)
  82 {
  83         m_query = m_query + STR_RIGHT_BRACKET;
  84 }
  85
  86 void CallHistoryFilter::visitAttribute(std::string& attrName, MatchFlag& matchFlag, Api::Tizen::AnyArrayPtr& values, int depth)
  87 {
  88         std::string str ("");
  89
  90         if (values == NULL) {
  91                 return;
  92         }
  93
  94         if (values->size() == 1) {
  95                 AnyPtr value = values->at(0);
  96                 str.append(convertAttribute(attrName, value));
  97         } else if (values->size() > 1) {
  98                 str.append(convertAttributeArray(attrName, values));
  99         }
 100
 101         m_query = m_query + str;
 102 }
 103
 104 void CallHistoryFilter::visitAttributeRange(std::string& attrName, AnyPtr& initialValue, AnyPtr& endValue, int depth)
 105 {
 106         string str ("");
 107         string name ("");
 108         string initialValueStr ("");
 109         string endValueStr ("");
 110
 111         if (attrName.compare("remoteParties.remoteParty") == 0) {
 112                 name = STR_NUMBER;
 113         } else if (attrName.compare("remoteParties.contactId") == 0) {
 114                 name = STR_CONTACT_ID;
 115         } else if (attrName.compare("startTime") == 0) {
 116                 name = STR_LOG_TIME;
 117         } else if (attrName.compare("duration") == 0) {
 118                 name = STR_DURATION;
 119         } else {
 120                 name = attrName;
 121         }
 122
 123         if (initialValue != NULL) {
 124                 if(initialValue->getType() == PrimitiveType_Time) {
 125                         tm date = initialValue->getDateTm();
 126                         std::stringstream time;
 127                         time << mktime(&date);
 128                         initialValueStr = time.str();
 129                 } else {
 130                         initialValueStr = initialValue->toString();
 131                 }
 132         }
 133
 134         if (endValue != NULL) {
 135                 if(endValue->getType() == PrimitiveType_Time) {
 136                         tm date = endValue->getDateTm();
 137                         std::stringstream time;
 138                         time << mktime(&date);
 139                         endValueStr = time.str();
 140
 141                 } else {
 142                         endValueStr = endValue->toString();
 143                 }
 144         }
 145
 146         if (initialValue != NULL && endValue == NULL) {
 147                 str = STR_LEFT_BRACKET + name + STR_GREATER_THAN + STR_EQUAL + STR_S_QUOTATION + initialValueStr + STR_S_QUOTATION + STR_RIGHT_BRACKET;
 148         } else if (initialValue == NULL && endValue != NULL) {
 149                 str = STR_LEFT_BRACKET + name + STR_LESS_THAN + STR_S_QUOTATION + endValueStr + STR_S_QUOTATION + STR_RIGHT_BRACKET;
 150         } else if (initialValue != NULL && endValue != NULL) {
 151                 str = STR_LEFT_BRACKET + name + STR_GREATER_THAN + STR_EQUAL + STR_S_QUOTATION + initialValueStr + STR_S_QUOTATION + STR_AND + name + STR_LESS_THAN + STR_S_QUOTATION + endValueStr + STR_S_QUOTATION + STR_RIGHT_BRACKET;
 152         }
 153
 154         m_query = m_query + str;
 155 }
 156
 157 void CallHistoryFilter::init()
 158 {
 159         m_query.clear();
 160         m_query.append(" WHERE");
 161 }
 162 std::string CallHistoryFilter::convertAttributeArray(std::string &name, AnyArrayPtr& values)
 163 {
 164         std::string query("");
 165         AnyArray::iterator it = values->begin();
 166         query.append(STR_LEFT_BRACKET);
 167
 168         do {
 169                 if (it != values->begin()) {
 170                         query.append(STR_OR);
 171                 }
 172                 query.append(convertAttribute(name, *it));
 173                 it++;
 174         } while(it != values->end());
 175
 176         query.append(STR_RIGHT_BRACKET);
 177         return query;
 178 }
 179
 180 std::string CallHistoryFilter::convertAttribute(std::string &name, AnyPtr& value)
 181 {
 182         std::string query("");
 183         if (name.compare("direction") == 0) {
 184                 if (value->toString().compare(STR_RECEIVED) == 0) {
 185                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_ANSWERED + STR_OR
 186                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_ANSWERED + STR_RIGHT_BRACKET;
 187                 } else if (value->toString().compare(STR_DIALED) == 0) {
 188                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_OUTGOING + STR_OR
 189                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_OUTGOING + STR_RIGHT_BRACKET;
 190                 } else if (value->toString().compare(STR_MISSED) == 0) {
 191                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_MISSED_CHECKED + STR_OR
 192                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_MISSED_CHECKED + STR_RIGHT_BRACKET;
 193                 } else if (value->toString().compare(STR_MISSED_NEW) == 0) {
 194                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_MISSED_UNCHECKED + STR_OR
 195                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_MISSED_UNCHECKED + STR_RIGHT_BRACKET;
 196                 } else if (value->toString().compare(STR_REJECTED) == 0) {
 197                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_REJECTED + STR_OR
 198                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_REJECTED  + STR_RIGHT_BRACKET;
 199                 } else if (value->toString().compare(STR_BLOCKED) == 0) {
 200                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_BLOCKED + STR_OR
 201                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_BLOCKED + STR_RIGHT_BRACKET;
 202                 } else {
 203                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + "=0" + STR_RIGHT_BRACKET;
 204                 }
 205         } else if (name.compare("tags") == 0) {
 206                 if (value->toString().compare(STR_CALL) == 0) {
 207                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_GREATER_THAN + STR_EQUAL + STR_VOICE_ANSWERED + STR_AND
 208                                         + STR_LOG_TYPE + STR_LESS_THAN + STR_EQUAL + STR_VIDEO_BLOCKED + STR_RIGHT_BRACKET;
 209                 } else if (value->toString().compare(STR_CALL_VOICE) == 0) {
 210                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_ANSWERED + STR_OR
 211                                         + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_OUTGOING + STR_OR
 212                                         + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_MISSED_UNCHECKED + STR_OR
 213                                         + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_MISSED_CHECKED + STR_OR
 214                                         + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_REJECTED + STR_OR
 215                                         + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_BLOCKED + STR_RIGHT_BRACKET;
 216                 } else if (value->toString().compare(STR_CALL_VIDEO) == 0) {
 217                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_ANSWERED + STR_OR
 218                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_OUTGOING + STR_OR
 219                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_MISSED_UNCHECKED + STR_OR
 220                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_MISSED_CHECKED + STR_OR
 221                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_REJECTED + STR_OR
 222                                         + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_BLOCKED + STR_RIGHT_BRACKET;
 223                 } else {
 224                         query = STR_LEFT_BRACKET + STR_LOG_TYPE + "=0" + STR_RIGHT_BRACKET;
 225                 }
 226         } else if (name.compare("remoteParties.remoteParty") == 0) {
 227                 query = STR_LEFT_BRACKET + STR_NUMBER + STR_EQUAL + STR_S_QUOTATION + value->toString() + STR_S_QUOTATION + STR_RIGHT_BRACKET;
 228         } else if (name.compare("remoteParties.contactId") == 0) {
 229                 query = STR_LEFT_BRACKET + STR_CONTACT_ID + STR_EQUAL + STR_S_QUOTATION + value->toString() + STR_S_QUOTATION + STR_RIGHT_BRACKET;
 230         } else if (name.compare("startTime") == 0) {
 231                 std::string dateStr ("");
 232                 if(value->getType() == PrimitiveType_Time) {
 233                         tm date = value->getDateTm();
 234                         std::stringstream time;
 235                         time << mktime(&date);
 236                         dateStr = time.str();
 237                 } else {
 238                         return query;
 239                 }
 240                 query = STR_LEFT_BRACKET + STR_LOG_TIME + STR_EQUAL + STR_S_QUOTATION + dateStr + STR_S_QUOTATION + STR_RIGHT_BRACKET;
 241         } else if (name.compare("duration") == 0) {
 242                 query = STR_LEFT_BRACKET + STR_DURATION + STR_EQUAL + STR_S_QUOTATION + value->toString() + STR_S_QUOTATION + STR_RIGHT_BRACKET;
 243         }
 244
 245         return query;
 246 }
 247
 248 std::string CallHistoryFilter::getResult() const
 249 {
 250         return m_query;
 251 }
 252
 253 }
 254 }
 255 }