- update filter to recognise ids

Author: andreychuk

filter/filter.go

@@ -12,8 +12,11 @@ import (
 )
 
 const (
-	id  = "id"
-	_id = "_id"
+	id   = "id"
+	_id  = "_id"
+	desc = "desc"
+	//ID ...
+	ID = "ID"
 )
 
 //Filter describe fiter query
@@ -27,13 +30,55 @@ type Filter struct {
 
 //BeforeFilter ...
 type BeforeFilter struct {
-	Skip   string
-	Limit  string
+	Skip   interface{}
+	Limit  interface{}
 	Where  map[string]interface{}
 	Sort   map[string]string
 	Search string
 }
 
+func (bf *BeforeFilter) getSort() []string {
+	var sort []string
+	sort = make([]string, 0)
+	for key, value := range bf.Sort {
+		if desc == strings.ToLower(value) {
+			key = "-" + key
+		}
+		sort = append(sort, key)
+	}
+	return sort
+}
+
+func (bf *BeforeFilter) getLimit() int {
+	return convertParam(bf.Limit)
+}
+
+func (bf *BeforeFilter) getSkip() int {
+	return convertParam(bf.Skip)
+}
+
+//convertParam to convert skip/limit to int
+//by default return 0
+func convertParam(param interface{}) int {
+	var result int
+	switch param.(type) {
+	default:
+		return int(0)
+	case float64:
+		result = int(param.(float64))
+	case string:
+		t, err := strconv.Atoi(param.(string))
+		if err != nil {
+			result = int(0)
+		}
+		result = t
+	}
+	if result < 0 {
+		return int(0)
+	}
+	return result
+}
+
 //GetSkip ...
 func (f *Filter) GetSkip() int {
 	return f.skip
@@ -70,36 +115,27 @@ func (f *Filter) AddQuery(q bson.M) {
 
 //GetFilterData ...
 func GetFilterData(filter string, t interface{}) Filter {
-
 	var f Filter
 	if filter != "" {
 		var tmp BeforeFilter
 		ffjson.Unmarshal([]byte(filter), &tmp)
-		f.limit, _ = strconv.Atoi(tmp.Limit)
-		f.skip, _ = strconv.Atoi(tmp.Skip)
-		f.search = tmp.Search
-
-		for key, value := range tmp.Sort {
-			if "desc" == strings.ToLower(value) {
-				key = "-" + key
-			}
-			f.sort = append(f.sort, key)
-		}
+		f.limit = tmp.getLimit()
+		f.skip = tmp.getSkip()
+		f.sort = tmp.getSort()
 		f.query = tmp.parseWhere(t)
 	}
 	return f
 }
 
-func (f *BeforeFilter) parseWhere(t interface{}) bson.M {
+func (bf *BeforeFilter) parseWhere(t interface{}) bson.M {
 	var q bson.M
-	for key, values := range f.Where {
+	for key, values := range bf.Where {
 		if key == "and" || key == "or" {
 			key = "$" + key
 			q = parseAnd(key, values.([]interface{}), q, t)
 		} else {
 			q = parse(key, values, q, t)
 		}
-
 	}
 	return q
 }
@@ -109,34 +145,85 @@ func parse(key string, values interface{}, q bson.M, t interface{}) bson.M {
 		key = _id
 	}
 	val := reflect.ValueOf(t)
+	var fieldType string
+	if val.FieldByName(convertName(key)).IsValid() == true {
+		fieldType = val.FieldByName(convertName(key)).Type().String()
+		if fieldType == "*time.Time" || fieldType == "time.Time" {
+			if q == nil {
+				q = bson.M{"$and": []bson.M{}}
+			} else {
+				if q["$and"] == nil {
+					q["$and"] = []bson.M{}
+				}
+			}
+			q = parseFilterDate("$and", key, values, q)
+		}
+		if fieldType == "bson.ObjectId" {
+			q = parseID(key, values, q)
+		}
+	}
+	return q
+}
+
+func addKeyToQuery(key string, q bson.M) bson.M {
 	if q == nil {
 		q = bson.M{key: []bson.M{}}
 	} else {
 		q[key] = []bson.M{}
 	}
-	fieldName := convertName(key)
-	var fieldType string
+	return q
+}
+
+func parseID(key string, values interface{}, q bson.M) bson.M {
+	q = addKeyToQuery(key, q)
 	for field, data := range values.(map[string]interface{}) {
-		if val.FieldByName(fieldName).IsValid() == true {
-			fieldType = val.FieldByName(fieldName).Type().String()
-			if fieldType == "bson.ObjectId" {
-				q = parseIDData(key, field, data, q)
+		ids := convertStringIDtoObjectID(data)
+		if len(ids) > 0 {
+			if field == "in" || field == "nin" || field == "all" {
+				q[key] = bson.M{"$" + field: ids}
 			}
 		}
 	}
 	return q
 }
 
-func parseIDData(key string, field string, data interface{}, q bson.M) bson.M {
-	IDS := prepareInIds(data.(string))
-	if len(IDS) > 0 {
-		if field == "in" || field == "nin" || field == "all" {
-			q[key] = bson.M{"$" + field: IDS}
+func parseAndIDData(key string, field string, data interface{}, q bson.M) bson.M {
+	if field == id {
+		field = _id
+	}
+	slice := data.(map[string]interface{})
+	for k, value := range slice {
+		IDS := convertStringIDtoObjectID(value)
+		if len(IDS) > 0 {
+			if k == "in" || k == "nin" || k == "all" {
+				q[key] = append(q[key].([]bson.M), bson.M{field: bson.M{"$" + k: IDS}})
+			}
 		}
 	}
 	return q
 }
 
+func convertStringIDtoObjectID(data interface{}) []bson.ObjectId {
+	var ids []bson.ObjectId
+	ids = make([]bson.ObjectId, 0)
+	switch data.(type) {
+	case []interface{}:
+		ids = prepareIDSArray(data.([]interface{}))
+	case string:
+		ids = prepareInIds(data.(string))
+	}
+	return ids
+}
+
+func prepareIDSArray(values []interface{}) []bson.ObjectId {
+	var ids []bson.ObjectId
+	ids = make([]bson.ObjectId, 0)
+	for _, id := range values {
+		ids = append(ids, bson.ObjectIdHex(id.(string)))
+	}
+	return ids
+}
+
 func parseAnd(key string, values []interface{}, q bson.M, t interface{}) bson.M {
 	val := reflect.ValueOf(t)
 	if q == nil {
@@ -164,29 +251,13 @@ func parseAnd(key string, values []interface{}, q bson.M, t interface{}) bson.M
 
 func convertName(name string) string {
 	if name == id || name == _id {
-		return "ID"
+		return ID
 	}
 	newName := []rune(name)
 	newName[0] = unicode.ToUpper(newName[0])
 	return string(newName)
 }
 
-func parseAndIDData(key string, field string, data interface{}, q bson.M) bson.M {
-	if field == id {
-		field = _id
-	}
-	slice := data.(map[string]interface{})
-	for k, value := range slice {
-		IDS := prepareInIds(value.(string))
-		if len(IDS) > 0 {
-			if k == "in" || k == "nin" || k == "all" {
-				q[key] = append(q[key].([]bson.M), bson.M{field: bson.M{"$" + k: IDS}})
-			}
-		}
-	}
-	return q
-}
-
 func parseFilterDate(key string, field string, data interface{}, q bson.M) bson.M {
 	for k, v := range data.(map[string]interface{}) {
 		if k == "lte" || k == "lt" || k == "gte" || k == "gt" {