src/media_filter.c

   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 <media_info_private.h>
  19 #include <media_util_private.h>
  20
  21 static const char *__get_order_str(media_content_order_e order_enum)
  22 {
  23         switch (order_enum) {
  24         case MEDIA_CONTENT_ORDER_ASC:
  25                 return "ASC ";
  26         case MEDIA_CONTENT_ORDER_DESC:
  27                 return "DESC ";
  28         default:
  29                 return " ";
  30         }
  31 }
  32
  33 static const char *__get_collate_str(media_content_collation_e collate_type)
  34 {
  35         switch (collate_type) {
  36         case MEDIA_CONTENT_COLLATE_NOCASE:
  37                 return " COLLATE NOCASE ";
  38         case MEDIA_CONTENT_COLLATE_RTRIM:
  39                 return " COLLATE RTRIM ";
  40         case MEDIA_CONTENT_COLLATE_LOCALIZED:
  41                 return " COLLATE localized ";
  42         default:
  43                 return " ";
  44         }
  45 }
  46
  47 static bool __check_collate_type(media_content_collation_e collate_type)
  48 {
  49         switch (collate_type) {
  50         case MEDIA_CONTENT_COLLATE_DEFAULT:
  51         case MEDIA_CONTENT_COLLATE_NOCASE:
  52         case MEDIA_CONTENT_COLLATE_RTRIM:
  53         case MEDIA_CONTENT_COLLATE_LOCALIZED:
  54                 return true;
  55         default:
  56                 return false;
  57         }
  58 }
  59
  60 static bool __check_order_type(media_content_order_e order)
  61 {
  62         switch (order) {
  63         case MEDIA_CONTENT_ORDER_ASC:
  64         case MEDIA_CONTENT_ORDER_DESC:
  65         case MEDIA_CONTENT_ORDER_OTHER:
  66                 return true;
  67         default:
  68                 return false;
  69         }
  70 }
  71
  72 int _media_filter_build_condition(bool is_full, const char *condition, media_content_collation_e collate_type, char **result)
  73 {
  74         content_retip_if_fail(condition);
  75         content_retip_if_fail(__check_collate_type(collate_type));
  76         content_retip_if_fail(result);
  77
  78         if (is_full)
  79                 *result = g_strdup_printf("(%s)", condition);
  80         else
  81                 *result = g_strdup_printf("(%s%s)", condition, __get_collate_str(collate_type));
  82
  83         content_debug("Condition : %s", *result);
  84
  85         return MEDIA_CONTENT_ERROR_NONE;
  86 }
  87
  88 int _media_filter_build_option(filter_h filter, char **result)
  89 {
  90         filter_s *_filter = (filter_s *)filter;
  91
  92         content_retip_if_fail(filter);
  93         content_retip_if_fail(result);
  94
  95         if (!STRING_VALID(_filter->order_keyword)) {
  96                 *result = g_strdup_printf(" LIMIT %d, %d", _filter->offset, _filter->count);
  97                 return MEDIA_CONTENT_ERROR_NONE;
  98         }
  99
 100         if (_filter->is_full_order) {
 101                 *result = g_strdup_printf("ORDER BY %s LIMIT %d, %d", _filter->order_keyword, _filter->offset, _filter->count);
 102                 return MEDIA_CONTENT_ERROR_NONE;
 103         }
 104
 105         if (_filter->order_type == MEDIA_CONTENT_ORDER_ASC || _filter->order_type == MEDIA_CONTENT_ORDER_DESC) {
 106                 *result = g_strdup_printf("ORDER BY %s%s%s LIMIT %d, %d",
 107                         _filter->order_keyword,
 108                         __get_collate_str(_filter->order_collate_type),
 109                         __get_order_str(_filter->order_type),
 110                         _filter->offset,
 111                         _filter->count);
 112         } else {
 113 #ifdef _USE_TVPD_MODE
 114                 *result = g_strdup_printf("%s LIMIT %d, %d", _filter->order_keyword, _filter->offset, _filter->count);
 115 #else
 116                 *result = g_strdup_printf("ORDER BY %s LIMIT %d, %d", _filter->order_keyword, _filter->offset, _filter->count);
 117 #endif
 118         }
 119
 120         return MEDIA_CONTENT_ERROR_NONE;
 121 }
 122
 123 int media_filter_create(filter_h *filter)
 124 {
 125         int ret = MEDIA_CONTENT_ERROR_NONE;
 126
 127         content_retip_if_fail(filter);
 128
 129         filter_s *_filter = g_new0(filter_s, 1);
 130
 131         _filter->storage_id = NULL;
 132         _filter->condition = NULL;
 133         _filter->order_keyword = NULL;
 134         _filter->order_type = -1;
 135         _filter->condition_collate_type = MEDIA_CONTENT_COLLATE_DEFAULT;
 136         _filter->order_collate_type = MEDIA_CONTENT_COLLATE_DEFAULT;
 137         _filter->offset = -1;
 138         _filter->count = -1;
 139         _filter->is_full_condition = false;
 140         _filter->is_full_order = false;
 141
 142         *filter = (filter_h)_filter;
 143
 144         return ret;
 145 }
 146
 147 int media_filter_destroy(filter_h filter)
 148 {
 149         filter_s *_filter = (filter_s *)filter;
 150
 151         content_retip_if_fail(filter);
 152
 153         g_free(_filter->storage_id);
 154         g_free(_filter->condition);
 155         g_free(_filter->order_keyword);
 156         g_free(_filter);
 157
 158         return MEDIA_CONTENT_ERROR_NONE;
 159 }
 160
 161 int media_filter_set_offset(filter_h filter, int offset, int count)
 162 {
 163         filter_s *_filter = (filter_s *)filter;
 164
 165         content_retip_if_fail(filter);
 166
 167         _filter->offset = offset;
 168         _filter->count = count;
 169
 170         return MEDIA_CONTENT_ERROR_NONE;
 171 }
 172
 173 int media_filter_set_condition(filter_h filter, const char *condition, media_content_collation_e collate_type)
 174 {
 175         int ret = MEDIA_CONTENT_ERROR_NONE;
 176         filter_s *_filter = (filter_s *)filter;
 177
 178         content_retip_if_fail(filter);
 179         content_retip_if_fail(STRING_VALID(condition));
 180         content_retip_if_fail(__check_collate_type(collate_type));
 181
 182         _filter->is_full_condition = false;
 183         g_free(_filter->condition);
 184
 185         _filter->condition = g_strdup(condition);
 186
 187         content_debug("Condition string : %s", _filter->condition);
 188
 189         _filter->condition_collate_type = collate_type;
 190
 191         return ret;
 192 }
 193
 194 int media_filter_set_order(filter_h filter, media_content_order_e order_type, const char *order_keyword, media_content_collation_e collate_type)
 195 {
 196         filter_s *_filter = (filter_s *)filter;
 197
 198         content_retip_if_fail(filter);
 199         content_retip_if_fail(STRING_VALID(order_keyword));
 200         content_retip_if_fail(__check_order_type(order_type));
 201         content_retip_if_fail(__check_collate_type(collate_type));
 202
 203         _filter->is_full_order = false;
 204
 205         g_free(_filter->order_keyword);
 206
 207         _filter->order_keyword = g_strdup(order_keyword);
 208         _filter->order_type = order_type;
 209         _filter->order_collate_type = collate_type;
 210
 211         return MEDIA_CONTENT_ERROR_NONE;
 212 }
 213 #ifdef _USE_TVPD_MODE
 214 int media_filter_set_storage(filter_h filter, const char *storage_id)
 215 {
 216         filter_s *_filter = (filter_s *)filter;
 217
 218         content_retip_if_fail(filter);
 219         content_retip_if_fail(STRING_VALID(storage_id));
 220
 221         g_free(_filter->storage_id);
 222         _filter->storage_id = g_strdup(storage_id);
 223
 224         content_debug("storage_id : %s", _filter->storage_id);
 225
 226         return MEDIA_CONTENT_ERROR_NONE;
 227 }
 228 #endif
 229 int media_filter_get_offset(filter_h filter, int *offset, int *count)
 230 {
 231         filter_s *_filter = (filter_s *)filter;
 232
 233         content_retip_if_fail(filter);
 234         content_retip_if_fail(offset);
 235         content_retip_if_fail(count);
 236
 237         *offset = _filter->offset;
 238         *count = _filter->count;
 239
 240         return MEDIA_CONTENT_ERROR_NONE;
 241 }
 242
 243 int media_filter_get_condition(filter_h filter, char **condition, media_content_collation_e *collate_type)
 244 {
 245         filter_s *_filter = (filter_s *)filter;
 246
 247         content_retip_if_fail(filter);
 248         content_retip_if_fail(condition);
 249         content_retip_if_fail(collate_type);
 250
 251         if (!_filter->is_full_condition)
 252                 *condition = g_strdup(_filter->condition);
 253
 254         *collate_type = _filter->condition_collate_type;
 255
 256         return MEDIA_CONTENT_ERROR_NONE;
 257 }
 258
 259 int media_filter_get_order(filter_h filter, media_content_order_e *order_type, char **order_keyword, media_content_collation_e *collate_type)
 260 {
 261         filter_s *_filter = (filter_s *)filter;
 262
 263         content_retip_if_fail(filter);
 264         content_retip_if_fail(order_type);
 265         content_retip_if_fail(order_keyword);
 266         content_retip_if_fail(collate_type);
 267
 268         if (!_filter->is_full_order)
 269                 *order_keyword = g_strdup(_filter->order_keyword);
 270
 271         *order_type = _filter->order_type;
 272         *collate_type = _filter->order_collate_type;
 273
 274         return MEDIA_CONTENT_ERROR_NONE;
 275 }
 276 // LCOV_EXCL_START
 277 int media_filter_set_condition_v2(filter_h filter, const char *condition)
 278 {
 279         filter_s *_filter = (filter_s *)filter;
 280
 281         content_retip_if_fail(filter);
 282         content_retip_if_fail(STRING_VALID(condition));
 283
 284         _filter->is_full_condition = true;
 285
 286         g_free(_filter->condition);
 287
 288         _filter->condition = g_strdup(condition);
 289
 290         content_debug("Condition string : %s", _filter->condition);
 291
 292         return MEDIA_CONTENT_ERROR_NONE;
 293 }
 294
 295 int media_filter_get_condition_v2(filter_h filter, char **condition)
 296 {
 297         filter_s *_filter = (filter_s *)filter;
 298
 299         content_retip_if_fail(filter);
 300         content_retip_if_fail(condition);
 301
 302         if (_filter->is_full_condition)
 303                 *condition = g_strdup(_filter->condition);
 304
 305         return MEDIA_CONTENT_ERROR_NONE;
 306 }
 307
 308 int media_filter_set_order_v2(filter_h filter, const char *order)
 309 {
 310         filter_s *_filter = (filter_s *)filter;
 311
 312         content_retip_if_fail(filter);
 313         content_retip_if_fail(STRING_VALID(order));
 314
 315         _filter->is_full_order = true;
 316
 317         g_free(_filter->order_keyword);
 318         _filter->order_keyword = g_strdup(order);
 319
 320         return MEDIA_CONTENT_ERROR_NONE;
 321 }
 322
 323 int media_filter_get_order_v2(filter_h filter, char **order)
 324 {
 325         filter_s *_filter = (filter_s *)filter;
 326
 327         content_retip_if_fail(filter);
 328         content_retip_if_fail(order);
 329
 330         if (_filter->is_full_order)
 331                 *order = g_strdup(_filter->order_keyword);
 332
 333         return MEDIA_CONTENT_ERROR_NONE;
 334 }
 335 // LCOV_EXCL_STOP