def filter( self, **kwargs ):
'''Filter item berdasarkan kunci :kwargs.
hanya untuk relasi jenis one-to-many dan many-to-many.
return:
SuperDocList
'''
if self._type is 'one-to-one':
raise RelationError, "this function only for one-to-many and or many-to-many relation"
if not self.__ready_db_read(): return None
_cond = self.__get_where_clause()
if not _cond: return None
if len(kwargs) > 0:
_cond.update( parse_query( kwargs ) )
if self._parent_class._echo == True:
print 'query: %s' % repr(_cond)
rel_class = self._get_rel_class()
rv = SuperDocList (
DocList( self._parent_class._monga,
rel_class,
self._parent_class._monga._db[rel_class._collection_name].find( _cond )
),
self._polymorphic
)
if self._order != None:
rv = rv.sort( **self._order )
return rv
def parse_query(self):
q = utils.parse_query(self.request.query)
if 'proj_id' in q:
try:
self.proj_id = int(q['proj_id'])
except Exception as e:
self.is_valid = False
self.error_m = 'Invalid argument: proj_id'
logging.warning('Exception on {} : parse_query - {}'.format(self.__class__.__name__, e.args))
else:
self.is_valid = False
self.error_m = 'No such project'
if 'from' in q:
try:
self.from_ = int(q['from'])
except Exception as e:
self.is_valid = False
self.error_m = 'Invalid argument: from'
logging.warning('Exception on {} : parse_query - {}'.format(self.__class__.__name__, e.args))
if 'count' in q:
try:
self.count = int(q['count'])
except Exception as e:
self.is_valid = False
self.error_m = 'Invalid argument: count'
logging.warning('Exception on {} : parse_query - {}'.format(self.__class__.__name__, e.args))
def find( self, **kwargs ):
'''Untuk mencari item berdasarkan kunci :kwargs,
hanya untuk relasi jenis one-to-many dan many-to-many.
'''
if self._type is 'one-to-one':
raise RelationError, "this function only for one-to-many and or many-to-many relation"
if not self.__ready_db_read(): return None
_cond = self.__get_where_clause()
if not _cond: return None
addf = kwargs
if '_id' in kwargs:
addf['_id'] = ObjectId(str(kwargs['_id']))
_cond.update( parse_query( addf ) )
if self._parent_class._echo == True:
print 'query: %s' % repr(_cond)
rel_class = self._get_rel_class()
rv = self._parent_class._monga._db[rel_class._collection_name].find_one( _cond )
if self._polymorphic == True:
rel_class = mapped_user_class_docs[rv['_metaname_']]
return rv and rel_class( self._parent_class._monga, **dictarg(rv) ) or None
def get(self, query_string=None, **kwargs):
qs = self._get_queryset(parse_query(query_string, **kwargs))
if qs.count() > 1:
raise MultipleObjectsReturned
if qs.count() < 1:
raise DoesNotExist
return qs[0]
def cupcakes_list():
last_id = parse_query('last-id')
query = { '_id': { '$gt': validate_object_id(last_id) } } if last_id else {}
cupcakes = db.cupcakes.find(query).sort('_id').limit(5)
return json_response({
'data': cupcakes
})
def songs_search():
message = parse_query('message')
if not message:
return songs_list()
query = {'$text': {'$search': message}}
songs = list(db.songs.find(query))
check_not_empty(songs)
return json_response({'data': songs})
def parse_query(self):
q = utils.parse_query(self.request.query)
if 'byid' in q:
try:
self.byid = int(q['byid'])
except Exception as e:
self.is_valid = False
self.error_m = 'Invalid argument: byid'
logging.warning('Exception on {} : parse_query - {}'.format(self.__class__.__name__, e.args))
else:
self.is_valid = False
self.error_m = 'Empty'
def parse_query(self):
q = utils.parse_query(self.request.query)
if 'my' in q:
self.my = q['my'] == '1'
if 's' in q:
self.s = q['s']
if len(self.s) < constants.STATUS_MIN_LEN or len(self.s) > constants.STATUS_MAX_LEN:
self.is_valid = False
self.error_m = 'Invalid argument s: length must be [{}, {}]'.format(constants.STATUS_MIN_LEN, constants.STATUS_MAX_LEN)
if self.s != 'open' and self.s != 'freeze' and self.s != 'closed' and self.s != 'fail':
self.is_valid = False
self.error_m = 'Invalid argument s: must be "open", "freeze", "closed" or "fail"'
def cupcakes_search():
message = parse_query('message')
if not message:
return cupcakes_list()
query = { '$text': { '$search': message } }
cupcakes = list(db.cupcakes.find(query))
check_not_empty(cupcakes)
return json_response({
'data': cupcakes
})
def _get_cond(self):
_cond = {}
for k, v in self._filter.iteritems():
if type(v) == this:
at = getattr(self._parent_class,str(v))
if at != None:
_cond[k] = type(at) == ObjectId and unicode(at) or at
else:
_cond[k] = v
if self._parent_class._monga.config.get('nometaname') == False:
_cond["_metaname_"] = self._rel_class_name
return parse_query(_cond)
def do_GET(self):
""" Handles GET query """
valid_attr_values = db_table_column_names(CATS_TABLE)
cats_number = db_table_size(CATS_TABLE)
error = self.query.check(self.path, valid_attr_values, cats_number)
if error:
self.response(error)
else:
# set sql query
query_params = parse_query(self.path)[1]
query = self._set_sql_query(query_params)
# get data from db
data = db_query_realdict(query)
# send data to client
self.response(data)
def songs_avg_difficulty():
level = parse_query('level')
query = {'level': int(level)} if level else {}
songs = list(
db.songs.aggregate([{
'$match': query
}, {
'$group': {
'_id': 'null',
'avgDifficulty': {
'$avg': '$difficulty'
}
}
}]))
check_not_empty(songs)
return json_response({'data': songs[0]})
def check(self, query_string, valid_attrs, cats_number):
"""
Check GET query parameters
"""
query_path, query_params = parse_query(query_string)
# path
path_error = self._check_path(query_path)
if path_error:
return path_error
# parameters
params_error = self._check_params(query_params)
if params_error:
return params_error
# 'attribute' parameter
if query_params.get('attribute'):
attr_error = self._check_attrs(query_params['attribute'],
valid_attrs)
if attr_error:
return attr_error
# 'order' parameter
if query_params.get('order'):
order_error = self._check_order(query_params)
if order_error:
return order_error
# 'offset' parameter
if query_params.get('offset'):
offset_error = self._check_offset(query_params['offset'],
cats_number)
if offset_error:
return offset_error
# 'limit' parameter
if query_params.get('limit'):
limit_error = self._check_limit(query_params['limit'])
if limit_error:
return limit_error
def query(self, **kwargs):
'''Get objects for quick delete or update.
Example:
user.messages.query(_id__in = [1,2,3]).delete()
'''
if self._type is 'one-to-one':
raise RelationError, "this function only for one-to-many and or many-to-many relation"
if not self.__ready_db_read(): return None
_cond = self.__get_where_clause()
if not _cond: return None
if len(kwargs) > 0:
_cond.update( parse_query( kwargs ) )
if self._parent_class._echo == True:
print 'query: %s' % repr(_cond)
rel_class = self._get_rel_class()
return self._parent_class._monga.col(rel_class).query(**_cond)
def get_options(self, query, defaults=DEFAULT_OPTIONS, **options):
return {**defaults, **parse_query(query, depth=1), **options}
def filter(self, query_string=None, **kwargs):
queries = parse_query(query_string, **kwargs)
self._query.extend(queries)
self._need_refresh = True
return self
def get_params(self, query, defaults=DEFAULT_PARAMS, **params):
return {**defaults, **parse_query(query), **params}
def filter(self, query_string=None, **kwargs):
return self._get_queryset(parse_query(query_string, **kwargs))
def where_value(self):
return parse_query( self._cond )
def all(self):
return self._get_queryset(parse_query('*:*'))
