Feature/summary report

api/route.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"finala/api/httpparameters"
 	"finala/api/storage"
+	"fmt"
 	"io/ioutil"
 	"net/http"
 	"net/url"
@@ -55,6 +56,20 @@ func (server *Server) GetExecutions(resp http.ResponseWriter, req *http.Request)
 	server.JSONWrite(resp, http.StatusOK, results)
 }
 
+func (server *Server) GetAccounts(resp http.ResponseWriter, req *http.Request) {
+	queryLimit, _ := strconv.Atoi(httpparameters.QueryParamWithDefault(req, "querylimit", storage.GetExecutionsQueryLimit))
+	params := mux.Vars(req)
+	executionID := params["executionID"]
+	accounts, err := server.storage.GetAccounts(executionID, queryLimit)
+
+	if err != nil {
+		server.JSONWrite(resp, http.StatusInternalServerError, HttpErrorResponse{Error: err.Error()})
+		return
+
+	}
+	server.JSONWrite(resp, http.StatusOK, accounts)
+}
+
 // GetResourceData return resuts details by resource type
 func (server *Server) GetResourceData(resp http.ResponseWriter, req *http.Request) {
 	queryParams := req.URL.Query()
@@ -186,3 +201,105 @@ func (server *Server) VersionHandler(resp http.ResponseWriter, req *http.Request
 	}
 	server.JSONWrite(resp, http.StatusOK, version)
 }
+
+//Returns json thingy wingy dingy i dont know how
+func (server *Server) GetReport(resp http.ResponseWriter, req *http.Request) {
+	queryParams := req.URL.Query()
+	params := mux.Vars(req)
+	executionID := params["executionID"]
+	filters := httpparameters.GetFilterQueryParamWithOutPrefix(queryParamFilterPrefix, queryParams)
+
+	log.WithFields(log.Fields{
+		"filter": filters,
+	}).Info("filter")
+
+	filterForSummary := make(map[string]string)
+	for filterKey, filterValue := range filters {
+		filterForSummary[filterKey] = filterValue
+	}
+
+	response, err := server.storage.GetSummary(executionID, filterForSummary)
+	if err != nil {
+		server.JSONWrite(resp, http.StatusInternalServerError, HttpErrorResponse{Error: err.Error()})
+		return
+
+	}
+
+	var result []map[string]interface{}
+	var attributeList []string
+
+	for resourceName, resourceSummary := range response {
+		fmt.Println(resourceName, resourceSummary) //sanity test
+		if resourceSummary.ResourceCount > 0 {
+			resourcesList, err := server.storage.GetResources(resourceName, executionID, filters)
+			if err != nil {
+				server.JSONWrite(resp, http.StatusInternalServerError, HttpErrorResponse{Error: err.Error()})
+				continue
+			}
+
+			log.WithFields(log.Fields{
+				"name":        resourceName,
+				"executionID": executionID,
+				"filter":      filters,
+			}).Info(resourcesList)
+
+			//can still fail for some odd reason so we check if the resource is actually there
+			if resourcesList[0] == nil {
+				server.JSONWrite(resp, http.StatusInternalServerError, HttpErrorResponse{Error: err.Error()})
+				return
+			}
+			data, ok := resourcesList[0]["Data"].(map[string]interface{})
+			if !ok {
+				//screw your log
+				continue
+			}
+			for key := range data {
+				if key == "Tag" {
+					continue
+				}
+				exists := false
+				for index := range attributeList {
+					if attributeList[index] == key {
+						exists = true
+					}
+				}
+				if !exists {
+					attributeList = append(attributeList, key)
+				}
+			}
+
+		}
+	}
+
+	for resourceName, resourceSummary := range response {
+		fmt.Println(resourceName, resourceSummary) //sanity test
+		if resourceSummary.ResourceCount > 0 {
+			resourcesList, err := server.storage.GetResources(resourceName, executionID, filters)
+			if err != nil {
+				server.JSONWrite(resp, http.StatusInternalServerError, HttpErrorResponse{Error: err.Error()})
+				continue
+			}
+			for _, element := range resourcesList {
+				data, ok := element["Data"].(map[string]interface{})
+				if !ok {
+					//screw your log
+					continue
+				}
+
+				delete(data, "Tag")
+
+				data["ResourceName"] = resourceName
+				for _, attrName := range attributeList {
+					_, ok := data[attrName]
+					if !ok {
+						data[attrName] = nil
+					}
+				}
+				result = append(result, data)
+			}
+
+		}
+	}
+
+	server.JSONWrite(resp, http.StatusOK, result)
+}

api/server.go

@@ -81,12 +81,14 @@ func (server *Server) BindEndpoints() {
 
 	server.router.HandleFunc("/api/v1/summary/{executionID}", server.GetSummary).Methods("GET")
 	server.router.HandleFunc("/api/v1/executions", server.GetExecutions).Methods("GET")
+	server.router.HandleFunc("/api/v1/accounts/{executionID}", server.GetAccounts).Methods(("GET"))
 	server.router.HandleFunc("/api/v1/resources/{type}", server.GetResourceData).Methods("GET")
 	server.router.HandleFunc("/api/v1/trends/{type}", server.GetResourceTrends).Methods("GET")
 	server.router.HandleFunc("/api/v1/tags/{executionID}", server.GetExecutionTags).Methods("GET")
 	server.router.HandleFunc("/api/v1/detect-events/{executionID}", server.DetectEvents).Methods("POST")
 	server.router.HandleFunc("/api/v1/version", server.VersionHandler).Methods("GET")
 	server.router.HandleFunc("/api/v1/health", server.HealthCheckHandler).Methods("GET")
+	server.router.HandleFunc("/api/v1/report/{executionID}", server.GetReport).Methods("GET")
 	server.router.NotFoundHandler = http.HandlerFunc(server.NotFoundRoute)
 
 }

api/server_test.go

@@ -235,8 +235,57 @@ func TestGetExecutions(t *testing.T) {
 
 		})
 	}
+}
+
+func TestGetAccounts(t *testing.T) {
+	ms, _ := MockServer()
+	ms.BindEndpoints()
+	ms.Serve()
+
+	testCases := []struct {
+		endpoint           string
+		expectedStatusCode int
+		Count              int
+	}{
+		{"/api/v1/accounts", http.StatusNotFound, 0},
+		{"/api/v1/accounts/1", http.StatusOK, 2},
+		{"/api/v1/accounts/err", http.StatusInternalServerError, 0},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.endpoint, func(t *testing.T) {
+
+			rr := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", test.endpoint, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ms.Router().ServeHTTP(rr, req)
+			if rr.Code != test.expectedStatusCode {
+				t.Fatalf("handler returned wrong status code: got %v want %v", rr.Code, test.expectedStatusCode)
+			}
+
+			if test.expectedStatusCode == http.StatusOK {
+				body, err := ioutil.ReadAll(rr.Body)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var accountsData []storage.Accounts
 
+				err = json.Unmarshal(body, &accountsData)
+				if err != nil {
+					t.Fatalf("Could not parse http response")
+				}
+
+				if len(accountsData) != test.Count {
+					t.Fatalf("unexpected accounts data response, got %d expected %d", len(accountsData), test.Count)
+				}
+			}
+		})
+	}
 }
+
 func TestSave(t *testing.T) {
 	ms, mockStorage := MockServer()
 	ms.BindEndpoints()
@@ -460,3 +509,54 @@ func TestVersion(t *testing.T) {
 	}
 
 }
+
+func TestReport(t *testing.T) {
+	ms, _ := MockServer()
+	ms.BindEndpoints()
+	ms.Serve()
+
+	testCases := []struct {
+		endpoint           string
+		expectedStatusCode int
+		Count              int
+	}{
+		{"/api/v1/report", http.StatusNotFound, 0},
+		{"/api/v1/report/1", http.StatusOK, 0},
+		{"/api/v1/report/err", http.StatusInternalServerError, 0},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.endpoint, func(t *testing.T) {
+			rr := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", test.endpoint, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ms.Router().ServeHTTP(rr, req)
+			if rr.Code != test.expectedStatusCode {
+				t.Fatalf("handler returned wrong status code: got %v want %v", rr.Code, test.expectedStatusCode)
+			}
+
+			if test.expectedStatusCode == http.StatusOK {
+				body, err := ioutil.ReadAll(rr.Body)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				reportData := &[]map[string]interface{}{}
+				err = json.Unmarshal(body, reportData)
+				if err != nil {
+					t.Fatalf("Could not parse http response")
+				}
+
+				if len(*reportData) != test.Count {
+					t.Fatalf("unexpected resources data response, got %d expected %d", len(*reportData), test.Count)
+				}
+			} else {
+				if test.expectedStatusCode != rr.Code {
+					t.Fatalf("unexpected status code, got %d expected %d", rr.Code, test.expectedStatusCode)
+				}
+			}
+		})
+	}
+}