sfa/senslab/parsing.py

   1
   2 import sys
   3 import httplib
   4 import json
   5 from collections import defaultdict
   6
   7 def strip_dictionnary (dict_to_strip):
   8         stripped_filter = []
   9         stripped_filterdict = {}
  10         for f in dict_to_strip :
  11                 stripped_filter.append(str(f).strip('|'))
  12
  13         stripped_filterdict = dict(zip(stripped_filter, dict_to_strip.values()))
  14
  15         return stripped_filterdict
  16
  17
  18 def filter_return_fields( dict_to_filter, return_fields):
  19         filtered_dict = {}
  20         for field in return_fields:
  21                 if field in dict_to_filter:
  22                         filtered_dict[field] = dict_to_filter[field]
  23         return filtered_dict
  24
  25
  26
  27 def parse_filter(list_to_filter, param_filter, type_of_list, return_fields=None) :
  28         list_type = { 'persons': {'str': 'hrn','int':'record_id'},\
  29          'keys':{'int':'key_id'},\
  30          'site':{'str':'login_base','int':'site_id'},\
  31           'node':{'str':'hostname','int':'node_id'},\
  32           'slice':{'str':'slice_hrn','int':'record_id_slice'},\
  33           'peers':{'str':'hrn'}}
  34
  35         if  param_filter is None and return_fields is None:
  36             return list_to_filter
  37
  38         if type_of_list not in list_type:
  39                 return []
  40
  41         return_filtered_list= []
  42
  43         for item in list_to_filter:
  44                 tmp_item = {}
  45
  46                 if type(param_filter) is list :
  47
  48                         for p_filter in param_filter:
  49                                 if type(p_filter) is int:
  50                                         if item[list_type[type_of_list]['int']] == p_filter :
  51                                                 if return_fields:
  52                                                         tmp_item = filter_return_fields(item,return_fields)
  53                                                 else:
  54                                                         tmp_item = item
  55                                                 return_filtered_list.append(tmp_item)
  56
  57                                 if type(p_filter) is str:
  58                                         if item[list_type[type_of_list]['str']] == str(p_filter) :
  59                                                 if return_fields:
  60                                                         tmp_item = filter_return_fields(item,return_fields)
  61                                                 else:
  62                                                         tmp_item = item
  63                                                 return_filtered_list.append(tmp_item)
  64
  65
  66                 elif type(param_filter) is dict:
  67                         #stripped_filterdict = strip_dictionnary(param_filter)
  68                         #tmp_copy = {}
  69                         #tmp_copy = item.copy()
  70                         #key_list = tmp_copy.keys()
  71                         #for key in key_list:
  72                                 #if key not in stripped_filterdict:
  73                                         #del tmp_copy[key]
  74
  75                         #rif the item matches the filter, returns it
  76                         founditem = []
  77                         check =  [ True for  k in param_filter.keys() if 'id' in k ]
  78                         dflt= defaultdict(str,param_filter)
  79
  80
  81
  82                         #founditem =  [ item for k in dflt if item[k] in dflt[k]]
  83                         for k in dflt:
  84                             if item[k] in dflt[k]:
  85                                founditem = [item]
  86
  87                         if founditem:
  88                             if return_fields:
  89                                 tmp_item = filter_return_fields(founditem[0],return_fields)
  90                             else:
  91                                 tmp_item = founditem[0]
  92                             return_filtered_list.append(tmp_item)
  93
  94
  95                         #if cmp(tmp_copy, stripped_filterdict) == 0:
  96                                 #if return_fields:
  97                                         #tmp_item = filter_return_fields(item,return_fields)
  98                                 #else:
  99
 100                                         #tmp_item = item
 101                                 #return_filtered_list.append(tmp_item)
 102         if return_filtered_list :
 103            return return_filtered_list
 104