def test_regex(self): for regex_instance in ( re.compile("a*b", re.IGNORECASE), Regex("a*b", re.IGNORECASE)): res = self.round_tripped({"r": regex_instance})["r"] self.assertEqual("a*b", res.pattern) res = self.round_tripped({"r": Regex("a*b", re.IGNORECASE)})["r"] self.assertEqual("a*b", res.pattern) self.assertEqual(re.IGNORECASE, res.flags) unicode_options = re.I|re.M|re.S|re.U|re.X regex = re.compile("a*b", unicode_options) res = self.round_tripped({"r": regex})["r"] self.assertEqual(unicode_options, res.flags) # Some tools may not add $options if no flags are set. res = json_util.loads('{"r": {"$regex": "a*b"}}')['r'] self.assertEqual(0, res.flags) self.assertEqual( Regex('.*', 'ilm'), json_util.loads( '{"r": {"$regex": ".*", "$options": "ilm"}}')['r']) # Check order. self.assertEqual( '{"$regex": ".*", "$options": "mx"}', json_util.dumps(Regex('.*', re.M | re.X))) self.assertEqual( '{"$regex": ".*", "$options": "mx"}', json_util.dumps(re.compile(b'.*', re.M | re.X)))
def get(self, id=None): if id is None: parser = reqparse.RequestParser() parser.add_argument('figure', type=str, required=False) parser.add_argument('issue', type=str, required=False) parser.add_argument('filters', type=int, required=True) args = parser.parse_args() # Check filters if args.filters is 1: # Add filters # Check which filter to apply figure_list = [Regex.from_native(re.compile(str(i).replace("\"", "")+'.*')) for i in args.figure.split(',') if len(i) > 2] for t in figure_list: t.flags ^= re.UNICODE issue_list = [Regex.from_native(re.compile(str(i).replace("\"", "")+'.*')) for i in args.issue.split(',') if len(i) > 2] for i in issue_list: i.flags ^= re.UNICODE s = create_dic(mongo.db.directory.find({ "$or": [ {"figure": {"$in": figure_list}}, {"federal_entity": {"$in": issue_list}} ] })) else: s = create_dic(mongo.db.directory.find({})) else: s = create_dic(mongo.db.directory.find({})) return jsonify(directory=s)
def test_regex(self): for regex_instance in (re.compile("a*b", re.IGNORECASE), Regex("a*b", re.IGNORECASE)): res = self.round_tripped({"r": regex_instance})["r"] self.assertEqual("a*b", res.pattern) res = self.round_tripped({"r": Regex("a*b", re.IGNORECASE)})["r"] self.assertEqual("a*b", res.pattern) self.assertEqual(re.IGNORECASE, res.flags) unicode_options = re.I | re.M | re.S | re.U | re.X regex = re.compile("a*b", unicode_options) res = self.round_tripped({"r": regex})["r"] self.assertEqual(unicode_options, res.flags) # Some tools may not add $options if no flags are set. # https://jira.mongodb.org/browse/CDRIVER-3773 self.assertRaises(ValueError, bsonjs_loads, '{"r": {"$regex": ' '"a*b"}}') self.assertEqual( Regex(".*", "ilm"), bsonjs_loads('{"r": {"$regex": ".*", "$options": "ilm"}}')['r']) # Order should be $regex then $options self.assertEqual( '{ "regex" : { "$regex" : ".*", "$options" : "mx" } }', bsonjs_dumps({"regex": Regex(".*", re.M | re.X)})) self.assertEqual( '{ "regex" : { "$regex" : ".*", "$options" : "mx" } }', bsonjs_dumps({"regex": re.compile(b".*", re.M | re.X)}))
def test_regex(self): for regex_instance in ( re.compile("a*b", re.IGNORECASE), Regex("a*b", re.IGNORECASE)): res = self.round_tripped({"r": regex_instance})["r"] self.assertEqual("a*b", res.pattern) res = self.round_tripped({"r": Regex("a*b", re.IGNORECASE)})["r"] self.assertEqual("a*b", res.pattern) self.assertEqual(re.IGNORECASE, res.flags) unicode_options = re.I | re.M | re.S | re.U | re.X regex = re.compile("a*b", unicode_options) res = self.round_tripped({"r": regex})["r"] self.assertEqual(unicode_options, res.flags) # Some tools may not add $options if no flags are set. res = bsonjs_loads('{"r": {"$regex": "a*b"}}')['r'] self.assertEqual(0, res.flags) self.assertEqual( Regex(".*", "ilm"), bsonjs_loads( '{"r": {"$regex": ".*", "$options": "ilm"}}')['r']) # Order should be $regex then $options self.assertEqual( '{ "regex" : { "$regex" : ".*", "$options" : "mx" } }', bsonjs_dumps({"regex": Regex(".*", re.M | re.X)})) self.assertEqual( '{ "regex" : { "$regex" : ".*", "$options" : "mx" } }', bsonjs_dumps({"regex": re.compile(b".*", re.M | re.X)}))
def get(self): parser = reqparse.RequestParser() parser.add_argument('group', type=str, required=False) parser.add_argument('type', type=str, required=False) parser.add_argument('issue', type=str, required=False) parser.add_argument('filters', type=int, required=True) parser.add_argument('page', type=int, required=True) args = parser.parse_args() # Check filters if args.filters is 1: # Add filters # Check which filter to apply type_list = [Regex.from_native(re.compile(str(i).replace("\"", "")+'.*')) for i in args.type.split(',') if len(i) > 2] for t in type_list: t.flags ^= re.UNICODE group_list = [Regex.from_native(re.compile(str(i).replace("\"", "")+'.*')) for i in args.group.split(',') if len(i) > 2] for g in group_list: g.flags ^= re.UNICODE issue_list = [Regex.from_native(re.compile(str(i).replace("\"", "")+'.*')) for i in args.issue.split(',') if len(i) > 2] for i in issue_list: i.flags ^= re.UNICODE s = create_dic(mongo.db.organizations.find({ "$or": [ {"social_group": {"$in": group_list}}, {"type": {"$in": type_list}}, {"geo_issue": {"$in": issue_list}} ] }).skip(args.page * 25).limit(25)) else: s = create_dic(mongo.db.organizations.find({}).skip(args.page * 25).limit(25)) return jsonify(organizations=s)
def _get_regex(data, position, as_class, tz_aware, uuid_subtype, compile_re): pattern, position = _get_c_string(data, position) bson_flags, position = _get_c_string(data, position) bson_re = Regex(pattern, bson_flags) if compile_re: return bson_re.compile(), position else: return bson_re, position
def _get_regex(data, position, as_class, tz_aware, uuid_subtype, compile_re): pattern, position = _get_c_string(data, position) bson_flags, position = _get_c_string(data, position) bson_re = Regex(pattern, bson_flags) if compile_re: return bson_re.try_compile(), position else: return bson_re, position
def test_sort_12(monty_sort, mongo_sort): docs = [{"a": Regex("^a")}, {"a": Regex("^b")}] sort = [("a", -1)] monty_c = monty_sort(docs, sort) mongo_c = mongo_sort(docs, sort) for i in range(len(docs)): assert next(mongo_c)["_id"] == next(monty_c)["_id"]
def search_artists(): params = {item[0]: item[1] for item in request.forms.items() if item[1]} if int(params.pop('name_search_condition')) and 'name' in params: params['name'] = Regex(params['name']) if int(params.pop('alias_search_condition')) and 'aliases.name' in params: params['aliases.name'] = Regex(params['aliases.name']) results = collection.find(params, { '_id': 0, 'name': 1, 'aliases.name': 1, 'rating.value': 1 }).sort([('rating.value', -1)]).limit(50) if params else [] return results
def test_qop_nin_10(monty_find, mongo_find): docs = [ { "a": [Regex("*")] }, ] spec = {"a": {"$nin": [[Regex("*")]]}} monty_c = monty_find(docs, spec) mongo_c = mongo_find(docs, spec) assert mongo_c.count() == 0 assert monty_c.count() == mongo_c.count()
def test_qop_lt_28(monty_find, mongo_find): regex_0 = Regex("^0") regex_a = Regex("^a") docs = [ {"a": regex_0}, ] spec = {"a": {"$lt": regex_a}} monty_c = monty_find(docs, spec) # Can't have RegEx as arg to predicate with pytest.raises(OperationFailure): next(monty_c)
def object_hook(dct, json_options=DEFAULT_JSON_OPTIONS): if "$oid" in dct: return ObjectId(str(dct["$oid"])) if "$ref" in dct: return DBRef(dct["$ref"], dct["$id"], dct.get("$db", None)) if "$date" in dct: return _get_date(dct, json_options) if "$regex" in dct: flags = 0 # PyMongo always adds $options but some other tools may not. for opt in dct.get("$options", ""): flags |= _RE_OPT_TABLE.get(opt, 0) return Regex(dct["$regex"], flags) if "$minKey" in dct: return MinKey() if "$maxKey" in dct: return MaxKey() if "$binary" in dct: return _get_binary(dct, json_options) if "$code" in dct: return Code(dct["$code"], dct.get("$scope")) if "$uuid" in dct: return uuid.UUID(dct["$uuid"]) if "$undefined" in dct: return None if "$numberLong" in dct: return Int64(dct["$numberLong"]) if "$timestamp" in dct: tsp = dct["$timestamp"] return Timestamp(tsp["t"], tsp["i"]) if "$numberDecimal" in dct: return Decimal128(dct["$numberDecimal"]) return dct
async def test_command_with_regex(self, test_db): await test_db.test.insert_one({'r': re.compile('.*')}) await test_db.test.insert_one({'r': Regex('.*')}) result = await test_db.command('aggregate', 'test', pipeline=[]) for doc in result['result']: assert isinstance(doc['r'], Regex)
def salesReportByCountry(self, year): from bson.regex import Regex pattern = '^' + str(year) regex = Regex(pattern) query = dict({'dateOfPurchase': {'$regex': regex}}) proj = dict({ 'dateOfPurchase': 1, 'extendedPrice': 1, 'country': 1, '_id': 0 }) order = [('country', 1), ('dateOfPurchase', 1)] results = {} ## put results from generic fetch into nested dictionaries for doc in self.genericFetch(query, proj, order): country = doc['country'] dop = doc['dateOfPurchase'] month = str(dop[5:7]) if country in results: temp = results[country] if month in temp: price = temp[month] + doc['extendedPrice'] else: price = doc['extendedPrice'] temp.update({month: price}) else: results.update({country: {month: doc['extendedPrice']}}) return results
def find_by_primary_key(self, *kwargs): args = {} for idx, pk in enumerate(self.__document.pk_fields): if pk == "id": args["_id"] = kwargs[idx] elif pk == 'company_key': company_key_is_list = type(kwargs[idx]) is list if company_key_is_list: args[pk] = {'$in': kwargs[idx]} else: args[pk] = kwargs[idx] else: is_case_insensitive_pk = 'insensitive_pk_fields' in self.__document._meta and pk in self.__document._meta['insensitive_pk_fields'] if not is_case_insensitive_pk: args[pk] = kwargs[idx] else: regex = Regex.from_native(re.compile("^" + kwargs[idx] + "$", re.IGNORECASE)) query_insensitive = {"$regex": regex} args[pk] = query_insensitive doc = self.__document.collection.find(args).limit(1) try: doc = doc[0] return doc except IndexError: raise DocumentNotFound("{} not found".format(self.__document.collection_name))
def object_hook(dct, compile_re=True): if "$oid" in dct: return ObjectId(str(dct["$oid"])) if "$ref" in dct: return DBRef(dct["$ref"], dct["$id"], dct.get("$db", None)) if "$date" in dct: secs = float(dct["$date"]) / 1000.0 return EPOCH_AWARE + datetime.timedelta(seconds=secs) if "$regex" in dct: flags = 0 # PyMongo always adds $options but some other tools may not. for opt in dct.get("$options", ""): flags |= _RE_OPT_TABLE.get(opt, 0) if compile_re: return re.compile(dct["$regex"], flags) else: return Regex(dct["$regex"], flags) if "$minKey" in dct: return MinKey() if "$maxKey" in dct: return MaxKey() if "$binary" in dct: if isinstance(dct["$type"], int): dct["$type"] = "%02x" % dct["$type"] subtype = int(dct["$type"], 16) if subtype >= 0xffffff80: # Handle mongoexport values subtype = int(dct["$type"][6:], 16) return Binary(base64.b64decode(dct["$binary"].encode()), subtype) if "$code" in dct: return Code(dct["$code"], dct.get("$scope")) if bson.has_uuid() and "$uuid" in dct: return bson.uuid.UUID(dct["$uuid"]) return dct
def search(prefix: str, mongo_client: MongoClient, collection_name: str) -> Cursor: if mongo_client is not None: regex: Regex = Regex('^{}'.format(prefix)) return mongo_client[DB_NAME][collection_name].find({DATA_FIELD: {"$regex" : regex}}, {DATA_FIELD: 1, ID_FIELD: 0}) else: raise IOError("Failed to connect to the DB.")
def delete_by_prefix(self, collection_name, field, prefix): try: pattern = re.compile('^' + prefix + '.*') regex = Regex.from_native(pattern) regex.flags ^= re.IGNORECASE self.db[collection_name].delete_many({field: {'$regex': regex}}) except Exception, e: raise e
def query_nstart(self, value): # DOESN'T START WITH if isinstance(value, list): value = value[0] return MongoQuery( {self.field: { '$not': Regex('^' + value + '.*', 'i') }})
def query_nend(self, value): # DOESN'T END WITH if isinstance(value, list): value = value[0] return MongoQuery( {self.field: { '$not': Regex('*.' + value + '$', 'i') }})
def test_validate_regex_valid_regex(): class MyModel(Model): field: Regex regex = Regex("^.*$") instance = MyModel(field=regex) assert isinstance(instance.field, Regex) assert instance.field == regex
def _get_regex( data: Any, view: Any, position: int, dummy0: Any, opts: CodecOptions, dummy1: Any ) -> Tuple[Regex, int]: """Decode a BSON regex to bson.regex.Regex or a python pattern object.""" pattern, position = _get_c_string(data, view, position, opts) bson_flags, position = _get_c_string(data, view, position, opts) bson_re = Regex(pattern, bson_flags) return bson_re, position
def query_nlike(self, value): # WILDCARD NOT CONTAINS if isinstance(value, list): value = value[0] return MongoQuery( {self.field: { '$not': Regex('.*' + value + '.*', 'i') }})
def bbc_articles(): # TODO consider adding more query parameters title = request.args.get('title', '') tag = request.args.get('tag', '') scraped_date = get_scraped_date(request) items = collection.find({ "$and": [{ 'title': Regex(title) }, { 'tag': Regex(tag) }, { 'scraped_date': scraped_date }] }) return dumps(items)
def constructHashtags(self, keywords): hashtags_list = [] for word in keywords: pattern = re.compile(word[1:], re.IGNORECASE) regex = Regex.from_native(pattern) regex.flags ^= re.UNICODE hashtags_list.append(regex) return hashtags_list
def _parse_canonical_regex(doc): """Decode a JSON regex to bson.regex.Regex.""" regex = doc['$regularExpression'] if len(doc) != 1: raise TypeError('Bad $regularExpression, extra field(s): %s' % (doc, )) if len(regex) != 2: raise TypeError('Bad $regularExpression must include only "pattern"' 'and "options" components: %s' % (doc, )) return Regex(regex['pattern'], regex['options'])
def test_qop_type_11(monty_find, mongo_find): docs = [{"a": Regex("^a")}, {"a": re.compile("^a")}] spec = {"a": {"$type": 11}} # regex monty_c = monty_find(docs, spec) mongo_c = mongo_find(docs, spec) assert mongo_c.count() == 2 assert monty_c.count() == mongo_c.count()
def test_command_with_regex(self): db = self.client.pymongo_test db.test.drop() db.test.insert_one({'r': re.compile('.*')}) db.test.insert_one({'r': Regex('.*')}) result = db.command('aggregate', 'test', pipeline=[]) for doc in result['result']: self.assertTrue(isinstance(doc['r'], Regex))
def test_sort_19(monty_sort, mongo_sort): docs = [ {"a": ["x", True]}, {"a": None}, {"a": []}, {"a": [5, []]}, {"a": {"s": 7}}, {"a": {"s": [9]}}, {"a": {"s": 10}}, {"a": 6}, {"a": 4}, {"a": [5, None]}, {"a": [5, [1]]}, {"a": [Decimal128("4.5"), Binary(b"0")]}, {"a": [{"s": 5}, False]}, {"a": [{"s": 9}]}, {"a": [True, "y"]}, {"a": Binary(b"a")}, {"a": b"bytes"}, {"a": ["abc"]}, {"a": "banana"}, {"a": "appple"}, {"a": [Regex("^a", "ix")]}, {"a": Regex("^b")}, {"a": Code("x", {"m": 0})}, {"a": Code("y")}, {"a": Code("y", {})}, {"a": Code("y", {"m": 0})}, {"a": MinKey()}, {"a": MaxKey()}, {"a": Timestamp(0, 1)}, {"a": Timestamp(1, 1)}, {"a": ObjectId(b"000000000000")}, {"a": ObjectId(b"000000000001")}, {"a": datetime(1900, 1, 1)}, {"a": datetime(1900, 1, 2)}, ] sort = [("a", 1)] monty_c = monty_sort(docs, sort) mongo_c = mongo_sort(docs, sort) for i in range(len(docs)): assert next(mongo_c)["_id"] == next(monty_c)["_id"]
def test_validate_pattern_valid_bson_regex(): class MyModel(Model): field: Pattern value = Regex("^.*$", flags="im") flags_int_value = re.compile("", flags=re.I | re.M).flags instance = MyModel(field=value) assert isinstance(instance.field, Pattern) assert instance.field.pattern == value.pattern assert instance.field.flags == flags_int_value
def _parse_legacy_regex(doc): pattern = doc["$regex"] # Check if this is the $regex query operator. if isinstance(pattern, Regex): return doc flags = 0 # PyMongo always adds $options but some other tools may not. for opt in doc.get("$options", ""): flags |= _RE_OPT_TABLE.get(opt, 0) return Regex(pattern, flags)
def like(field, value): escaped_value = re.escape(value.replace('%', '')) if value.startswith('%') and value.endswith('%'): value = re.compile('.*' + escaped_value + '.*', re.IGNORECASE) elif value.startswith('%'): value = re.compile(escaped_value + '$', re.IGNORECASE) elif value.endswith('%'): value = re.compile('^' + escaped_value, re.IGNORECASE) return {field: {'$regex': Regex.from_native(value)}}
def get_ist_item(self, path=",Whole Program,", starting=False, ending=True): if type(path) is not list: path = [path] patterns = [] for p in path: patterns.append(("^" if starting else "") + p + ("$" if ending else "")) pattern = re.compile("|".join(patterns)) regex = Regex.from_native(pattern) regex.flags ^= re.UNICODE return self.ist.find({ "_id": regex })
def get_list_of_nodes(self, sorting_order=None, name_filter=None, pagination=None): sort_direction = ASCENDING filter_object = {} skip_count = 0 skip_limit = 0 if sorting_order: if sorting_order['name'].lower() == 'asc': sort_direction = ASCENDING elif sorting_order['name'].lower() == 'desc': sort_direction = DESCENDING if name_filter: name_pattern = Regex.from_native(re.compile('^' + name_filter['name'])) filter_object = {'name': name_pattern} if pagination: skip_count = int(pagination['skip']) skip_limit = int(pagination['limit']) return list( self.computation_nodes_collection.find(filter_object, {'name': True, 'address': True, 'port': True, '_id': False}, sort=[('name', sort_direction)], skip=skip_count, limit=skip_limit))
def calculate_sum_of_expenditure_types(self, query_params): # Build match pipeline match = { "$match": {} } if query_params['tipPodataka'] != []: match['$match']["tipPodataka.slug"] = {'$in': query_params['tipPodataka']} if "klasifikacija" in query_params: if query_params['klasifikacija']['broj'] != []: query_params['klasifikacija']['broj'] = [str(i) for i in query_params['klasifikacija']['broj']] if "filteri" in query_params: ### Let's set the values rage for ukupno ### if "ukupno" in query_params["filteri"] and 'veceIliJednako' in query_params["filteri"]['ukupno']: if 'ukupno' not in match['$match']: match['$match']["ukupno"] = {} match['$match']["ukupno"]["$gte"] = query_params["filteri"]["ukupno"]["veceIliJednako"] if "ukupno" in query_params["filteri"] and 'manjeIliJednako' in query_params["filteri"]['ukupno']: if 'ukupno' not in match['$match']: match['$match']["ukupno"] = {} match['$match']["ukupno"]["$lte"] = query_params["filteri"]["ukupno"]["manjeIliJednako"] ### Let's set the values rage for sopstveniPrihodi ### if "sopstveniPrihodi" in query_params["filteri"] and 'veceIliJednako' in query_params["filteri"]['sopstveniPrihodi']: if 'sopstveniPrihodi' not in match['$match']: match['$match']["sopstveniPrihodi"] = {} match['$match']["sopstveniPrihodi"]["$gte"] = query_params["filteri"]["sopstveniPrihodi"]["veceIliJednako"] if "sopstveniPrihodi" in query_params["filteri"] and 'manjeIliJednako' in query_params["filteri"]['sopstveniPrihodi']: if 'sopstveniPrihodi' not in match['$match']: match['$match']["sopstveniPrihodi"] = {} match['$match']["sopstveniPrihodi"]["$lte"] = query_params["filteri"]["sopstveniPrihodi"]["manjeIliJednako"] ### Let's set the values rage for prihodiBudzeta ### if "prihodiBudzeta" in query_params["filteri"] and 'veceIliJednako' in query_params["filteri"]['prihodiBudzeta']: if 'prihodiBudzeta' not in match['$match']: match['$match']["prihodiBudzeta"] = {} match['$match']["prihodiBudzeta"]["$gte"] = query_params["filteri"]["prihodiBudzeta"]["veceIliJednako"] if "prihodiBudzeta" in query_params["filteri"] and 'manjeIliJednako' in query_params["filteri"]['prihodiBudzeta']: if 'prihodiBudzeta' not in match['$match']: match['$match']["prihodiBudzeta"] = {} match['$match']["prihodiBudzeta"]["$lte"] = query_params["filteri"]["prihodiBudzeta"]["manjeIliJednako"] ### Let's set the values rage for donacije ### if "donacije" in query_params["filteri"] and 'veceIliJednako' in query_params["filteri"]['donacije']: if 'donacije' not in match['$match']: match['$match']["donacije"] = {} match['$match']["donacije"]["$gte"] = query_params["filteri"]["donacije"]["veceIliJednako"] if "donacije" in query_params["filteri"] and 'manjeIliJednako' in query_params["filteri"]['donacije']: if 'donacije' not in match['$match']: match['$match']["donacije"] = {} match['$match']["donacije"]["$lte"] = query_params["filteri"]["donacije"]["manjeIliJednako"] ### Let's set the values rage for ostali ### if "ostali" in query_params["filteri"] and 'veceIliJednako' in query_params["filteri"]['ostali']: if 'ostali' not in match['$match']: match['$match']["ostali"] = {} match['$match']["ostali"]["$gte"] = query_params["filteri"]["ostali"]["veceIliJednako"] if "ostali" in query_params["filteri"] and 'manjeIliJednako' in query_params["filteri"]['ostali']: if 'ostali' not in match['$match']: match['$match']["ostali"] = {} match['$match']["ostali"]["$lte"] = query_params["filteri"]["ostali"]["manjeIliJednako"] # Add other filters if query_params['godine'] != []: match['$match']["godina"] = {'$in': query_params['godine']} if "opstine" in query_params: if query_params['opstine'] != []: match['$match']["opstina.slug"] = {'$in': query_params['opstine']} # Build group pipeline group = { "$group": { "_id": { "opstina": "$opstina.latinica", "godina": "$godina", "tipPodataka": "$tipPodataka.vrednost" }, "prihodiBudzeta": {"$sum": "$prihodiBudzeta"}, "sopstveniPrihodi": {"$sum": "$sopstveniPrihodi"}, "donacije": {"$sum": "$donacije"}, "ostali": {"$sum": "$ostali"}, "ukupno": {"$sum": "$ukupno"} } } # Build project pipeline project = { "$project": { "_id": 0, "opstina": "$_id.opstina", "godina": "$_id.godina", "tipPodataka": "$_id.tipPodataka", "prihodiBudzeta": "$prihodiBudzeta", "sopstveniPrihodi": "$sopstveniPrihodi", "donacije": "$donacije", "ostali": "$ostali", "ukupno": "$ukupno", } } if "klasifikacija" in query_params: if query_params['klasifikacija']['broj'] != []: if 'pocinjeSa' in query_params['klasifikacija'] and query_params['klasifikacija']['pocinjeSa'] != '': # Let's filter based on class options we picked and regex class number match['$match']['$or'] = [] match_class_number = {"klasifikacija.broj": {'$in': query_params['klasifikacija']['broj']}} match['$match']['$or'].append(match_class_number) # Since Pymongo driver works with python regex logic, our pattern should be adopted in a way that python # regex compiler understands, then convert it to a BSON Regex instance, # read more: http://api.mongodb.org/python/current/api/bson/regex.html pattern = re.compile("^%s" % query_params['klasifikacija']['pocinjeSa']) regex = Regex.from_native(pattern) regex.flags ^= re.UNICODE # Build match pipeline match_regex = { "klasifikacija.broj": regex } match['$match']['$or'].append(match_regex) else: match['$match']["klasifikacija.broj"] = {'$in': query_params['klasifikacija']['broj']} else: if query_params['klasifikacija']['pocinjeSa'] != '': pattern = re.compile("^%s" % query_params['klasifikacija']['pocinjeSa']) regex = Regex.from_native(pattern) regex.flags ^= re.UNICODE # Build match pipeline match['$match']["klasifikacija.broj"] = regex # Add this to param to group and project stages group['$group']['_id']['klasifikacijaBroj'] = "$klasifikacija.broj" project['$project']['klasifikacijaBroj'] = '$_id.klasifikacijaBroj' elif "kategorijaRoditelj" in query_params: if query_params['kategorijaRoditelj'] != []: match['$match']["kategorijaRoditelj.broj"] = {'$in': query_params['kategorijaRoditelj']} group['$group']['_id']['kategorijaRoditelj'] = "$kategorijaRoditelj.broj" project['$project']['kategorijaRoditelj'] = '$_id.kategorijaRoditelj' # Execute mongo request json_doc = mongo.db.opstine.aggregate([match, group, project]) return json_doc['result']