func (i *uploadController) ReadMany(c context.Context) error {

	var results []types.Upload
	qry := elastigo.Search(iname).Pretty().Query(
		elastigo.Query().All(),
	)
	out, err := qry.Result(types.ElasticConnection)
	if err != nil {
		fmt.Println("err querying elastic connection:%v", err)
		return goweb.API.RespondWithError(c, http.StatusInternalServerError,
			err.Error())
	}

	for _, elem := range out.Hits.Hits {
		bytes, err := elem.Source.MarshalJSON()
		if err != nil {
			log.Println("err calling marshalJson:%v", err)
			return goweb.API.RespondWithError(c, http.StatusInternalServerError,
				err.Error())
		}
		var t types.Upload
		json.Unmarshal(bytes, &t)
		results = append(results, t)
	}

	return goweb.API.RespondWithData(c, results)
}
Exemple #2
0
func searchHandler(w http.ResponseWriter, r *http.Request) {
	var index, typ string

	r.ParseForm()
	switch r.Form.Get("type") {
	case "slack":
		index = slack.Index
		typ = "message"
	}
	if len(index) == 0 {
		http.Error(w, "unrecognise type", 500)
		return
	}
	out, err := el.Search(index).Type(typ).Search(r.Form.Get("query")).Result(conn)
	if err != nil {
		http.Error(w, err.Error(), 500)
		return
	}

	var results []*json.RawMessage
	for _, hit := range out.Hits.Hits {
		results = append(results, hit.Source)
	}
	b, err := json.Marshal(map[string]interface{}{
		"type":    index,
		"results": results,
	})
	if err != nil {
		http.Error(w, err.Error(), 500)
		return
	}
	w.Write(b)
}
Exemple #3
0
// Search ES index
func Search(sr *proto.SearchRequest) (string, error) {
	if len(sr.Query) <= 0 {
		sr.Query = "*"
	}
	size := fmt.Sprintf("%d", sr.Limit)
	from := fmt.Sprintf("%d", sr.Offset)

	out, err := lib.Search(sr.Index).Type(sr.Type).Size(size).From(from).Search(sr.Query).Result(conn)
	if err != nil {
		return "", err
	}

	return string(out.RawJSON), nil
}
Exemple #4
0
func (c *Configuration) fetchLastIndexFromES() int64 {
	var results []Upload

	qry := elastigo.Search(iname).Pretty().Query(
		elastigo.Query().All(),
	)
	out, err := qry.Result(ElasticConnection)

	if err != nil {
		log.Println("No record found")
		return 0
	}

	if out.Hits.Total == 0 {
		log.Println("No indice data for updating fetch information")
		return 0
	}

	for _, elem := range out.Hits.Hits {
		bytes, err := elem.Source.MarshalJSON()
		if err != nil {
			log.Fatalf("err calling marshalJson:%v", err)
		}
		var t Upload
		json.Unmarshal(bytes, &t)
		results = append(results, t)
	}

	var highestId int64 = 0

	for _, p := range results {
		if p.Id >= highestId {
			highestId = p.Id
		}
	}
	return highestId
}
Exemple #5
0
// Build elasticsearch query from vindalu query
func buildElasticsearchBaseQuery(index string, req map[string]interface{}) (query map[string]interface{}, err error) {

	filterOps := []interface{}{}

	for k, v := range req {
		switch v.(type) {
		case string:
			val, _ := v.(string)
			val = strings.TrimSpace(val)
			if strings.HasPrefix(val, ">") || strings.HasPrefix(val, "<") {
				// Parse number
				aVal := ""
				if strings.HasPrefix(val, ">=") || strings.HasPrefix(val, "<=") {
					aVal = strings.TrimSpace(val[2:])
				} else {
					aVal = strings.TrimSpace(val[1:])
				}
				// Parse number for comparison
				var nVal interface{}
				nVal, ierr := strconv.ParseInt(aVal, 10, 64)
				if ierr != nil {
					ierr = nil
					if nVal, ierr = strconv.ParseFloat(aVal, 64); ierr != nil {
						err = ierr
						return
					}
				}
				// Add range filterop
				if strings.HasPrefix(val, ">") {
					filterOps = append(filterOps, elastigo.Range().Field(k).Gt(nVal))
				} else {
					filterOps = append(filterOps, elastigo.Range().Field(k).Lt(nVal))
				}

			} else {
				if isRegexSearch(val) {
					filterOps = append(filterOps, regexFilter(k, val))
				} else {
					filterOps = append(filterOps, map[string]interface{}{
						"term": map[string]string{k: val},
					})
				}
			}
			break
		case int:
			break
		case int64:
			break
		case float64:
			break
		case []interface{}:
			break
		case interface{}:
			break
		default:
			err = fmt.Errorf("invalid type: %#v", v)
			return
		}
	}

	if len(filterOps) > 0 {
		query = map[string]interface{}{
			"query": map[string]interface{}{
				"filtered": elastigo.Search(index).Filter(filterOps...),
			},
		}
	} else {
		// Empty query i.e. return everything
		query = map[string]interface{}{}
	}

	return
}
/*
{
	"type": ["virtualserver", "physicalserver"],
	"os": "ubuntu"
}
*/
func (ir *Inventory) parseRequestBody(r *http.Request) (query interface{}, err error) {

	// check happens earlier
	var body []byte
	if body, err = ioutil.ReadAll(r.Body); err != nil {
		return
	}
	defer r.Body.Close()

	var req map[string]interface{}
	if err = json.Unmarshal(body, &req); err != nil {
		return
	}

	filterOps := []interface{}{}

	for k, v := range req {
		switch v.(type) {
		case string:
			val, _ := v.(string)
			val = strings.TrimSpace(val)
			if strings.HasPrefix(val, ">") || strings.HasPrefix(val, "<") {
				// Parse number
				aVal := ""
				if strings.HasPrefix(val, ">=") || strings.HasPrefix(val, "<=") {
					aVal = strings.TrimSpace(val[2:])
				} else {
					aVal = strings.TrimSpace(val[1:])
				}
				// Parse number for comparison
				var nVal interface{}
				nVal, ierr := strconv.ParseInt(aVal, 10, 64)
				if ierr != nil {
					ierr = nil
					if nVal, ierr = strconv.ParseFloat(aVal, 64); ierr != nil {
						err = ierr
						return
					}
				}
				// Add range filterop
				if strings.HasPrefix(val, ">") {
					filterOps = append(filterOps, elastigo.Range().Field(k).Gt(nVal))
				} else {
					filterOps = append(filterOps, elastigo.Range().Field(k).Lt(nVal))
				}

			} else {
				filterOps = append(filterOps, elastigo.Filter().Terms(k, val))
			}
			break
		case int:
			//val, _ := v.(int)
			break
		case int64:
			//val, _ := v.(int64)
			break
		case float64:
			//val, _ := v.(float64)
			break
		case []interface{}:
			vals, _ := v.([]interface{})
			filterOps = append(filterOps, elastigo.Filter().Terms(k, vals...))
			break
		case interface{}:
			//val, _ := v.(interface{})
			break
		default:
			err = fmt.Errorf("invalid type: %#v", v)
			return
		}
	}

	query = elastigo.Search(ir.cfg.Datastore.Config.Index).Filter(filterOps...)

	return
}