diff --git a/cmd/crowdsec-cli/capi.go b/cmd/crowdsec-cli/capi.go index 7862c965f..11d4000d3 100644 --- a/cmd/crowdsec-cli/capi.go +++ b/cmd/crowdsec-cli/capi.go @@ -20,8 +20,7 @@ import ( ) const CAPIBaseURL string = "https://api.crowdsec.net/" -const CAPIURLPrefix = "v2" - +const CAPIURLPrefix = "v3" func NewCapiCmd() *cobra.Command { var cmdCapi = &cobra.Command{ @@ -47,7 +46,6 @@ func NewCapiCmd() *cobra.Command { return cmdCapi } - func NewCapiRegisterCmd() *cobra.Command { var capiUserPrefix string var outputFile string @@ -122,7 +120,6 @@ func NewCapiRegisterCmd() *cobra.Command { return cmdCapiRegister } - func NewCapiStatusCmd() *cobra.Command { var cmdCapiStatus = &cobra.Command{ Use: "status", diff --git a/cmd/crowdsec-cli/console.go b/cmd/crowdsec-cli/console.go index 5cf74a41b..163b6d79b 100644 --- a/cmd/crowdsec-cli/console.go +++ b/cmd/crowdsec-cli/console.go @@ -102,7 +102,7 @@ After running this command your will need to validate the enrollment in the weba Scenarios: scenarios, UserAgent: fmt.Sprintf("crowdsec/%s", cwversion.VersionStr()), URL: apiURL, - VersionPrefix: "v2", + VersionPrefix: "v3", }) resp, err := c.Auth.EnrollWatcher(context.Background(), args[0], name, tags, overwrite) if err != nil { diff --git a/pkg/apiclient/client_test.go b/pkg/apiclient/client_test.go index 7bbc08d1b..3b55dce07 100644 --- a/pkg/apiclient/client_test.go +++ b/pkg/apiclient/client_test.go @@ -21,9 +21,13 @@ import ( */ func setup() (mux *http.ServeMux, serverURL string, teardown func()) { + return setupWithPrefix("v1") +} + +func setupWithPrefix(urlPrefix string) (mux *http.ServeMux, serverURL string, teardown func()) { // mux is the HTTP request multiplexer used with the test server. mux = http.NewServeMux() - baseURLPath := "/v1" + baseURLPath := "/" + urlPrefix apiHandler := http.NewServeMux() apiHandler.Handle(baseURLPath+"/", http.StripPrefix(baseURLPath, mux)) diff --git a/pkg/apiclient/decisions_service.go b/pkg/apiclient/decisions_service.go index e2b32e888..f7844fb8a 100644 --- a/pkg/apiclient/decisions_service.go +++ b/pkg/apiclient/decisions_service.go @@ -1,12 +1,18 @@ package apiclient import ( + "bufio" "context" "fmt" + "io" "net/http" "github.com/crowdsecurity/crowdsec/pkg/models" + "github.com/crowdsecurity/crowdsec/pkg/modelscapi" + "github.com/crowdsecurity/crowdsec/pkg/types" qs "github.com/google/go-querystring/query" + "github.com/pkg/errors" + log "github.com/sirupsen/logrus" ) type DecisionsService service @@ -67,15 +73,140 @@ func (s *DecisionsService) List(ctx context.Context, opts DecisionsListOpts) (*m if err != nil { return nil, resp, err } + return &decisions, resp, nil } -func (s *DecisionsService) GetStream(ctx context.Context, opts DecisionsStreamOpts) (*models.DecisionsStreamResponse, *Response, error) { +func (s *DecisionsService) FetchV2Decisions(ctx context.Context, url string) (*models.DecisionsStreamResponse, *Response, error) { var decisions models.DecisionsStreamResponse + + req, err := s.client.NewRequest(http.MethodGet, url, nil) + if err != nil { + return nil, nil, err + } + + resp, err := s.client.Do(ctx, req, &decisions) + if err != nil { + return nil, resp, err + } + + return &decisions, resp, nil +} + +func (s *DecisionsService) GetDecisionsFromGroups(decisionsGroups []*modelscapi.GetDecisionsStreamResponseNewItem) []*models.Decision { + var decisions []*models.Decision + + for _, decisionsGroup := range decisionsGroups { + partialDecisions := make([]*models.Decision, len(decisionsGroup.Decisions)) + for idx, decision := range decisionsGroup.Decisions { + partialDecisions[idx] = &models.Decision{ + Scenario: decisionsGroup.Scenario, + Scope: decisionsGroup.Scope, + Type: types.StrPtr(types.DecisionTypeBan), + Value: decision.Value, + Duration: decision.Duration, + Origin: types.StrPtr(types.CAPIOrigin), + } + } + decisions = append(decisions, partialDecisions...) + } + return decisions +} + +func (s *DecisionsService) FetchV3Decisions(ctx context.Context, url string) (*models.DecisionsStreamResponse, *Response, error) { + var decisions modelscapi.GetDecisionsStreamResponse + var v2Decisions models.DecisionsStreamResponse + + scenarioDeleted := "deleted" + durationDeleted := "1h" + + req, err := s.client.NewRequest(http.MethodGet, url, nil) + if err != nil { + return nil, nil, err + } + + resp, err := s.client.Do(ctx, req, &decisions) + if err != nil { + return nil, resp, err + } + + v2Decisions.New = s.GetDecisionsFromGroups(decisions.New) + for _, decisionsGroup := range decisions.Deleted { + partialDecisions := make([]*models.Decision, len(decisionsGroup.Decisions)) + for idx, decision := range decisionsGroup.Decisions { + decision := decision // fix exportloopref linter message + partialDecisions[idx] = &models.Decision{ + Scenario: &scenarioDeleted, + Scope: decisionsGroup.Scope, + Type: types.StrPtr(types.DecisionTypeBan), + Value: &decision, + Duration: &durationDeleted, + Origin: types.StrPtr(types.CAPIOrigin), + } + } + v2Decisions.Deleted = append(v2Decisions.Deleted, partialDecisions...) + } + + return &v2Decisions, resp, nil +} + +func (s *DecisionsService) GetDecisionsFromBlocklist(ctx context.Context, blocklist *modelscapi.BlocklistLink) ([]*models.Decision, error) { + if blocklist.URL == nil { + return nil, errors.New("blocklist URL is nil") + } + + log.Debugf("Fetching blocklist %s", *blocklist.URL) + + req, err := s.client.NewRequest(http.MethodGet, *blocklist.URL, nil) + if err != nil { + return nil, err + } + + pr, pw := io.Pipe() + defer pr.Close() + go func() { + defer pw.Close() + _, err = s.client.Do(ctx, req, pw) + if err != nil { + log.Errorf("Error fetching blocklist %s: %s", *blocklist.URL, err) + } + }() + decisions := make([]*models.Decision, 0) + scanner := bufio.NewScanner(pr) + for scanner.Scan() { + decision := scanner.Text() + decisions = append(decisions, &models.Decision{ + Scenario: blocklist.Name, + Scope: blocklist.Scope, + Type: blocklist.Remediation, + Value: &decision, + Duration: blocklist.Duration, + Origin: types.StrPtr(types.ListOrigin), + }) + } + + return decisions, nil +} + +func (s *DecisionsService) GetStream(ctx context.Context, opts DecisionsStreamOpts) (*models.DecisionsStreamResponse, *Response, error) { u, err := opts.addQueryParamsToURL(s.client.URLPrefix + "/decisions/stream") if err != nil { return nil, nil, err } + if s.client.URLPrefix == "v3" { + return s.FetchV3Decisions(ctx, u) + } else { + return s.FetchV2Decisions(ctx, u) + } +} + +func (s *DecisionsService) GetStreamV3(ctx context.Context, opts DecisionsStreamOpts) (*modelscapi.GetDecisionsStreamResponse, *Response, error) { + u, err := opts.addQueryParamsToURL(s.client.URLPrefix + "/decisions/stream") + if err != nil { + return nil, nil, err + } + var decisions modelscapi.GetDecisionsStreamResponse + req, err := s.client.NewRequest(http.MethodGet, u, nil) if err != nil { return nil, nil, err diff --git a/pkg/apiclient/decisions_service_test.go b/pkg/apiclient/decisions_service_test.go index 313ce240e..92a9c448a 100644 --- a/pkg/apiclient/decisions_service_test.go +++ b/pkg/apiclient/decisions_service_test.go @@ -10,6 +10,7 @@ import ( "github.com/crowdsecurity/crowdsec/pkg/cwversion" "github.com/crowdsecurity/crowdsec/pkg/models" + "github.com/crowdsecurity/crowdsec/pkg/modelscapi" log "github.com/sirupsen/logrus" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -192,6 +193,263 @@ func TestDecisionsStream(t *testing.T) { } } +func TestDecisionsStreamV3Compatibility(t *testing.T) { + log.SetLevel(log.DebugLevel) + + mux, urlx, teardown := setupWithPrefix("v3") + defer teardown() + + mux.HandleFunc("/decisions/stream", func(w http.ResponseWriter, r *http.Request) { + + assert.Equal(t, r.Header.Get("X-Api-Key"), "ixu") + testMethod(t, r, http.MethodGet) + if r.Method == http.MethodGet { + if r.URL.RawQuery == "startup=true" { + w.WriteHeader(http.StatusOK) + w.Write([]byte(`{"deleted":[{"scope":"ip","decisions":["1.2.3.5"]}],"new":[{"scope":"ip", "scenario": "manual 'ban' from '82929df7ee394b73b81252fe3b4e50203yaT2u6nXiaN7Ix9'", "decisions":[{"duration":"3h59m55.756182786s","value":"1.2.3.4"}]}]}`)) + } else { + w.WriteHeader(http.StatusOK) + w.Write([]byte(`{"deleted":null,"new":null}`)) + } + } + }) + + apiURL, err := url.Parse(urlx + "/") + if err != nil { + t.Fatalf("parsing api url: %s", apiURL) + } + + //ok answer + auth := &APIKeyTransport{ + APIKey: "ixu", + } + + newcli, err := NewDefaultClient(apiURL, "v3", "toto", auth.Client()) + if err != nil { + t.Fatalf("new api client: %s", err) + } + + tduration := "3h59m55.756182786s" + torigin := "CAPI" + tscenario := "manual 'ban' from '82929df7ee394b73b81252fe3b4e50203yaT2u6nXiaN7Ix9'" + tscope := "ip" + ttype := "ban" + tvalue := "1.2.3.4" + tvalue1 := "1.2.3.5" + tscenarioDeleted := "deleted" + tdurationDeleted := "1h" + expected := &models.DecisionsStreamResponse{ + New: models.GetDecisionsResponse{ + &models.Decision{ + Duration: &tduration, + Origin: &torigin, + Scenario: &tscenario, + Scope: &tscope, + Type: &ttype, + Value: &tvalue, + }, + }, + Deleted: models.GetDecisionsResponse{ + &models.Decision{ + Duration: &tdurationDeleted, + Origin: &torigin, + Scenario: &tscenarioDeleted, + Scope: &tscope, + Type: &ttype, + Value: &tvalue1, + }, + }, + } + + // GetStream is supposed to consume v3 payload and return v2 response + decisions, resp, err := newcli.Decisions.GetStream(context.Background(), DecisionsStreamOpts{Startup: true}) + require.NoError(t, err) + + if resp.Response.StatusCode != http.StatusOK { + t.Errorf("Alerts.List returned status: %d, want %d", resp.Response.StatusCode, http.StatusOK) + } + + if err != nil { + t.Fatalf("new api client: %s", err) + } + if !reflect.DeepEqual(*decisions, *expected) { + t.Fatalf("returned %+v, want %+v", resp, expected) + } +} + +func TestDecisionsStreamV3(t *testing.T) { + log.SetLevel(log.DebugLevel) + + mux, urlx, teardown := setupWithPrefix("v3") + defer teardown() + + mux.HandleFunc("/decisions/stream", func(w http.ResponseWriter, r *http.Request) { + + assert.Equal(t, r.Header.Get("X-Api-Key"), "ixu") + testMethod(t, r, http.MethodGet) + if r.Method == http.MethodGet { + w.WriteHeader(http.StatusOK) + w.Write([]byte(`{"deleted":[{"scope":"ip","decisions":["1.2.3.5"]}], + "new":[{"scope":"ip", "scenario": "manual 'ban' from '82929df7ee394b73b81252fe3b4e50203yaT2u6nXiaN7Ix9'", "decisions":[{"duration":"3h59m55.756182786s","value":"1.2.3.4"}]}], + "links": {"blocklists":[{"name":"blocklist1","url":"/v3/blocklist","scope":"ip","remediation":"ban","duration":"24h"}]}}`)) + } + }) + + apiURL, err := url.Parse(urlx + "/") + if err != nil { + t.Fatalf("parsing api url: %s", apiURL) + } + + //ok answer + auth := &APIKeyTransport{ + APIKey: "ixu", + } + + newcli, err := NewDefaultClient(apiURL, "v3", "toto", auth.Client()) + if err != nil { + t.Fatalf("new api client: %s", err) + } + + tduration := "3h59m55.756182786s" + tscenario := "manual 'ban' from '82929df7ee394b73b81252fe3b4e50203yaT2u6nXiaN7Ix9'" + tscope := "ip" + tvalue := "1.2.3.4" + tvalue1 := "1.2.3.5" + tdurationBlocklist := "24h" + tnameBlocklist := "blocklist1" + tremediationBlocklist := "ban" + tscopeBlocklist := "ip" + turlBlocklist := "/v3/blocklist" + expected := &modelscapi.GetDecisionsStreamResponse{ + New: modelscapi.GetDecisionsStreamResponseNew{ + &modelscapi.GetDecisionsStreamResponseNewItem{ + Decisions: []*modelscapi.GetDecisionsStreamResponseNewItemDecisionsItems0{ + { + Duration: &tduration, + Value: &tvalue, + }, + }, + Scenario: &tscenario, + Scope: &tscope, + }, + }, + Deleted: modelscapi.GetDecisionsStreamResponseDeleted{ + &modelscapi.GetDecisionsStreamResponseDeletedItem{ + Scope: &tscope, + Decisions: []string{ + tvalue1, + }, + }, + }, + Links: &modelscapi.GetDecisionsStreamResponseLinks{ + Blocklists: []*modelscapi.BlocklistLink{ + { + Duration: &tdurationBlocklist, + Name: &tnameBlocklist, + Remediation: &tremediationBlocklist, + Scope: &tscopeBlocklist, + URL: &turlBlocklist, + }, + }, + }, + } + + // GetStream is supposed to consume v3 payload and return v2 response + decisions, resp, err := newcli.Decisions.GetStreamV3(context.Background(), DecisionsStreamOpts{Startup: true}) + require.NoError(t, err) + + if resp.Response.StatusCode != http.StatusOK { + t.Errorf("Alerts.List returned status: %d, want %d", resp.Response.StatusCode, http.StatusOK) + } + + if err != nil { + t.Fatalf("new api client: %s", err) + } + if !reflect.DeepEqual(*decisions, *expected) { + t.Fatalf("returned %+v, want %+v", resp, expected) + } +} + +func TestDecisionsFromBlocklist(t *testing.T) { + log.SetLevel(log.DebugLevel) + + mux, urlx, teardown := setupWithPrefix("v3") + defer teardown() + + mux.HandleFunc("/blocklist", func(w http.ResponseWriter, r *http.Request) { + + assert.Equal(t, r.Header.Get("X-Api-Key"), "ixu") + testMethod(t, r, http.MethodGet) + if r.Method == http.MethodGet { + w.WriteHeader(http.StatusOK) + w.Write([]byte("1.2.3.4\r\n1.2.3.5")) + } + }) + + apiURL, err := url.Parse(urlx + "/") + if err != nil { + t.Fatalf("parsing api url: %s", apiURL) + } + + //ok answer + auth := &APIKeyTransport{ + APIKey: "ixu", + } + + newcli, err := NewDefaultClient(apiURL, "v3", "toto", auth.Client()) + if err != nil { + t.Fatalf("new api client: %s", err) + } + + tvalue1 := "1.2.3.4" + tvalue2 := "1.2.3.5" + tdurationBlocklist := "24h" + tnameBlocklist := "blocklist1" + tremediationBlocklist := "ban" + tscopeBlocklist := "ip" + turlBlocklist := "/v3/blocklist" + torigin := "lists" + expected := []*models.Decision{ + { + Duration: &tdurationBlocklist, + Value: &tvalue1, + Scenario: &tnameBlocklist, + Scope: &tscopeBlocklist, + Type: &tremediationBlocklist, + Origin: &torigin, + }, + { + Duration: &tdurationBlocklist, + Value: &tvalue2, + Scenario: &tnameBlocklist, + Scope: &tscopeBlocklist, + Type: &tremediationBlocklist, + Origin: &torigin, + }, + } + decisions, err := newcli.Decisions.GetDecisionsFromBlocklist(context.Background(), &modelscapi.BlocklistLink{ + URL: &turlBlocklist, + Scope: &tscopeBlocklist, + Remediation: &tremediationBlocklist, + Name: &tnameBlocklist, + Duration: &tdurationBlocklist, + }) + require.NoError(t, err) + + log.Infof("decision1: %+v", decisions[0]) + log.Infof("expected1: %+v", expected[0]) + log.Infof("decisions: %s, %s, %s, %s, %s, %s", *decisions[0].Value, *decisions[0].Duration, *decisions[0].Scenario, *decisions[0].Scope, *decisions[0].Type, *decisions[0].Origin) + log.Infof("expected : %s, %s, %s, %s, %s", *expected[0].Value, *expected[0].Duration, *expected[0].Scenario, *expected[0].Scope, *expected[0].Type) + log.Infof("decisions: %s, %s, %s, %s, %s", *decisions[1].Value, *decisions[1].Duration, *decisions[1].Scenario, *decisions[1].Scope, *decisions[1].Type) + + if err != nil { + t.Fatalf("new api client: %s", err) + } + if !reflect.DeepEqual(decisions, expected) { + t.Fatalf("returned %+v, want %+v", decisions, expected) + } +} + func TestDeleteDecisions(t *testing.T) { mux, urlx, teardown := setup() mux.HandleFunc("/watchers/login", func(w http.ResponseWriter, r *http.Request) { diff --git a/pkg/apiserver/apic.go b/pkg/apiserver/apic.go index d82b4354f..009da967b 100644 --- a/pkg/apiserver/apic.go +++ b/pkg/apiserver/apic.go @@ -4,6 +4,7 @@ import ( "context" "fmt" "math/rand" + "net/http" "net/url" "strconv" "strings" @@ -22,6 +23,7 @@ import ( "github.com/crowdsecurity/crowdsec/pkg/database/ent/alert" "github.com/crowdsecurity/crowdsec/pkg/database/ent/decision" "github.com/crowdsecurity/crowdsec/pkg/models" + "github.com/crowdsecurity/crowdsec/pkg/modelscapi" "github.com/crowdsecurity/crowdsec/pkg/types" ) @@ -188,7 +190,7 @@ func NewAPIC(config *csconfig.OnlineApiClientCfg, dbClient *database.Client, con UserAgent: fmt.Sprintf("crowdsec/%s", cwversion.VersionStr()), URL: apiURL, PapiURL: papiURL, - VersionPrefix: "v2", + VersionPrefix: "v3", Scenarios: ret.scenarioList, UpdateScenario: ret.FetchScenariosListFromDB, }) @@ -380,11 +382,41 @@ func (a *apic) HandleDeletedDecisions(deletedDecisions []*models.Decision, delet if err != nil { return 0, errors.Wrapf(err, "converting db ret %d", dbCliDel) } - updateCounterForDecision(delete_counters, decision, dbCliDel) + updateCounterForDecision(delete_counters, decision.Origin, decision.Scenario, dbCliDel) nbDeleted += dbCliDel } return nbDeleted, nil +} +func (a *apic) HandleDeletedDecisionsV3(deletedDecisions []*modelscapi.GetDecisionsStreamResponseDeletedItem, delete_counters map[string]map[string]int) (int, error) { + var filter map[string][]string + var nbDeleted int + for _, decisions := range deletedDecisions { + scope := decisions.Scope + for _, decision := range decisions.Decisions { + if strings.ToLower(*scope) == "ip" { + filter = make(map[string][]string, 1) + filter["value"] = []string{decision} + } else { + filter = make(map[string][]string, 2) + filter["value"] = []string{decision} + filter["scopes"] = []string{*scope} + } + filter["origin"] = []string{types.CAPIOrigin} + + dbCliRet, _, err := a.dbClient.SoftDeleteDecisionsWithFilter(filter) + if err != nil { + return 0, errors.Wrap(err, "deleting decisions error") + } + dbCliDel, err := strconv.Atoi(dbCliRet) + if err != nil { + return 0, errors.Wrapf(err, "converting db ret %d", dbCliDel) + } + updateCounterForDecision(delete_counters, types.StrPtr(types.CAPIOrigin), nil, dbCliDel) + nbDeleted += dbCliDel + } + } + return nbDeleted, nil } func createAlertsForDecisions(decisions []*models.Decision) []*models.Alert { @@ -454,7 +486,7 @@ func createAlertForDecision(decision *models.Decision) *models.Alert { func fillAlertsWithDecisions(alerts []*models.Alert, decisions []*models.Decision, add_counters map[string]map[string]int) []*models.Alert { for _, decision := range decisions { //count and create separate alerts for each list - updateCounterForDecision(add_counters, decision, 1) + updateCounterForDecision(add_counters, decision.Origin, decision.Scenario, 1) /*CAPI might send lower case scopes, unify it.*/ switch strings.ToLower(*decision.Scope) { @@ -489,7 +521,7 @@ func fillAlertsWithDecisions(alerts []*models.Alert, decisions []*models.Decisio return alerts } -// we receive only one list of decisions, that we need to break-up : +// we receive a list of decisions and links for blocklist and we need to create a list of alerts : // one alert for "community blocklist" // one alert per list we're subscribed to func (a *apic) PullTop() error { @@ -503,7 +535,7 @@ func (a *apic) PullTop() error { log.Infof("Starting community-blocklist update") - data, _, err := a.apiClient.Decisions.GetStream(context.Background(), apiclient.DecisionsStreamOpts{Startup: a.startup}) + data, _, err := a.apiClient.Decisions.GetStreamV3(context.Background(), apiclient.DecisionsStreamOpts{Startup: a.startup}) if err != nil { return errors.Wrap(err, "get stream") } @@ -512,10 +544,13 @@ func (a *apic) PullTop() error { log.Debugf("Received %d new decisions", len(data.New)) log.Debugf("Received %d deleted decisions", len(data.Deleted)) + if data.Links != nil { + log.Debugf("Received %d blocklists links", len(data.Links.Blocklists)) + } add_counters, delete_counters := makeAddAndDeleteCounters() // process deleted decisions - if nbDeleted, err := a.HandleDeletedDecisions(data.Deleted, delete_counters); err != nil { + if nbDeleted, err := a.HandleDeletedDecisionsV3(data.Deleted, delete_counters); err != nil { return err } else { log.Printf("capi/community-blocklist : %d explicit deletions", nbDeleted) @@ -526,12 +561,25 @@ func (a *apic) PullTop() error { return nil } - // we receive only one list of decisions, that we need to break-up : - // one alert for "community blocklist" - // one alert per list we're subscribed to - alertsFromCapi := createAlertsForDecisions(data.New) - alertsFromCapi = fillAlertsWithDecisions(alertsFromCapi, data.New, add_counters) + // create one alert for community blocklist using the first decision + decisions := a.apiClient.Decisions.GetDecisionsFromGroups(data.New) + alert := createAlertForDecision(decisions[0]) + alertsFromCapi := []*models.Alert{alert} + alertsFromCapi = fillAlertsWithDecisions(alertsFromCapi, decisions, add_counters) + err = a.SaveAlerts(alertsFromCapi, add_counters, delete_counters) + if err != nil { + return errors.Wrap(err, "while saving alerts") + } + + // update blocklists + if err := a.UpdateBlocklists(data.Links, add_counters); err != nil { + return errors.Wrap(err, "while updating blocklists") + } + return nil +} + +func (a *apic) SaveAlerts(alertsFromCapi []*models.Alert, add_counters map[string]map[string]int, delete_counters map[string]map[string]int) error { for idx, alert := range alertsFromCapi { alertsFromCapi[idx] = setAlertScenario(add_counters, delete_counters, alert) log.Debugf("%s has %d decisions", *alertsFromCapi[idx].Source.Scope, len(alertsFromCapi[idx].Decisions)) @@ -544,6 +592,49 @@ func (a *apic) PullTop() error { } log.Printf("%s : added %d entries, deleted %d entries (alert:%d)", *alertsFromCapi[idx].Source.Scope, inserted, deleted, alertID) } + + return nil +} + +func (a *apic) UpdateBlocklists(links *modelscapi.GetDecisionsStreamResponseLinks, add_counters map[string]map[string]int) error { + if links == nil { + return nil + } + if links.Blocklists == nil { + return nil + } + // we must use a different http client than apiClient's because the transport of apiClient is jwtTransport or here we have signed apis that are incompatibles + // we can use the same baseUrl as the urls are absolute and the parse will take care of it + defaultClient, err := apiclient.NewDefaultClient(a.apiClient.BaseURL, "", "", &http.Client{}) + if err != nil { + return errors.Wrap(err, "while creating default client") + } + for _, blocklist := range links.Blocklists { + if blocklist.Scope == nil { + log.Warningf("blocklist has no scope") + continue + } + if blocklist.Duration == nil { + log.Warningf("blocklist has no duration") + continue + } + decisions, err := defaultClient.Decisions.GetDecisionsFromBlocklist(context.Background(), blocklist) + if err != nil { + return errors.Wrapf(err, "while getting decisions from blocklist %s", *blocklist.Name) + } + if len(decisions) == 0 { + log.Infof("blocklist %s has no decisions", *blocklist.Name) + continue + } + alert := createAlertForDecision(decisions[0]) + alertsFromCapi := []*models.Alert{alert} + alertsFromCapi = fillAlertsWithDecisions(alertsFromCapi, decisions, add_counters) + + err = a.SaveAlerts(alertsFromCapi, add_counters, nil) + if err != nil { + return errors.Wrapf(err, "while saving alert from blocklist %s", *blocklist.Name) + } + } return nil } @@ -691,12 +782,12 @@ func makeAddAndDeleteCounters() (map[string]map[string]int, map[string]map[strin return add_counters, delete_counters } -func updateCounterForDecision(counter map[string]map[string]int, decision *models.Decision, totalDecisions int) { - if *decision.Origin == types.CAPIOrigin { - counter[*decision.Origin]["all"] += totalDecisions - } else if *decision.Origin == types.ListOrigin { - counter[*decision.Origin][*decision.Scenario] += totalDecisions +func updateCounterForDecision(counter map[string]map[string]int, origin *string, scenario *string, totalDecisions int) { + if *origin == types.CAPIOrigin { + counter[*origin]["all"] += totalDecisions + } else if *origin == types.ListOrigin { + counter[*origin][*scenario] += totalDecisions } else { - log.Warningf("Unknown origin %s", *decision.Origin) + log.Warningf("Unknown origin %s", *origin) } } diff --git a/pkg/apiserver/apic_test.go b/pkg/apiserver/apic_test.go index 01abe9571..740776eb0 100644 --- a/pkg/apiserver/apic_test.go +++ b/pkg/apiserver/apic_test.go @@ -26,6 +26,7 @@ import ( "github.com/crowdsecurity/crowdsec/pkg/database/ent/decision" "github.com/crowdsecurity/crowdsec/pkg/database/ent/machine" "github.com/crowdsecurity/crowdsec/pkg/models" + "github.com/crowdsecurity/crowdsec/pkg/modelscapi" "github.com/crowdsecurity/crowdsec/pkg/types" ) @@ -220,7 +221,7 @@ func TestNewAPIC(t *testing.T) { setConfig() httpmock.Activate() defer httpmock.DeactivateAndReset() - httpmock.RegisterResponder("POST", "http://foobar/v2/watchers/login", httpmock.NewBytesResponder( + httpmock.RegisterResponder("POST", "http://foobar/v3/watchers/login", httpmock.NewBytesResponder( 200, jsonMarshalX( models.WatcherAuthResponse{ Code: 200, @@ -518,7 +519,7 @@ func TestFillAlertsWithDecisions(t *testing.T) { func TestAPICPullTop(t *testing.T) { api := getAPIC(t) api.dbClient.Ent.Decision.Create(). - SetOrigin(types.ListOrigin). + SetOrigin(types.CAPIOrigin). SetType("ban"). SetValue("9.9.9.9"). SetScope("Ip"). @@ -531,62 +532,65 @@ func TestAPICPullTop(t *testing.T) { defer httpmock.DeactivateAndReset() httpmock.RegisterResponder("GET", "http://api.crowdsec.net/api/decisions/stream", httpmock.NewBytesResponder( 200, jsonMarshalX( - models.DecisionsStreamResponse{ - Deleted: models.GetDecisionsResponse{ - &models.Decision{ - Origin: types.StrPtr(types.ListOrigin), - Scenario: types.StrPtr("crowdsecurity/ssh-bf"), - Value: types.StrPtr("9.9.9.9"), - Scope: types.StrPtr("Ip"), - Duration: types.StrPtr("24h"), - Type: types.StrPtr("ban"), + modelscapi.GetDecisionsStreamResponse{ + Deleted: modelscapi.GetDecisionsStreamResponseDeleted{ + &modelscapi.GetDecisionsStreamResponseDeletedItem{ + Decisions: []string{ + "9.9.9.9", // This is already present in DB + "9.1.9.9", // This not present in DB + }, + Scope: types.StrPtr("Ip"), }, // This is already present in DB - &models.Decision{ - Origin: types.StrPtr(types.ListOrigin), - Scenario: types.StrPtr("crowdsecurity/ssh-bf"), - Value: types.StrPtr("9.1.9.9"), - Scope: types.StrPtr("Ip"), - Duration: types.StrPtr("24h"), - Type: types.StrPtr("ban"), - }, // This not present in DB. }, - New: models.GetDecisionsResponse{ - &models.Decision{ - Origin: types.StrPtr(types.CAPIOrigin), + New: modelscapi.GetDecisionsStreamResponseNew{ + &modelscapi.GetDecisionsStreamResponseNewItem{ Scenario: types.StrPtr("crowdsecurity/test1"), - Value: types.StrPtr("1.2.3.4"), Scope: types.StrPtr("Ip"), - Duration: types.StrPtr("24h"), - Type: types.StrPtr("ban"), + Decisions: []*modelscapi.GetDecisionsStreamResponseNewItemDecisionsItems0{ + { + Value: types.StrPtr("1.2.3.4"), + Duration: types.StrPtr("24h"), + }, + }, }, - &models.Decision{ - Origin: types.StrPtr(types.CAPIOrigin), + &modelscapi.GetDecisionsStreamResponseNewItem{ Scenario: types.StrPtr("crowdsecurity/test2"), - Value: types.StrPtr("1.2.3.5"), Scope: types.StrPtr("Ip"), - Duration: types.StrPtr("24h"), - Type: types.StrPtr("ban"), + Decisions: []*modelscapi.GetDecisionsStreamResponseNewItemDecisionsItems0{ + { + Value: types.StrPtr("1.2.3.5"), + Duration: types.StrPtr("24h"), + }, + }, }, // These two are from community list. - &models.Decision{ - Origin: types.StrPtr(types.ListOrigin), - Scenario: types.StrPtr("crowdsecurity/http-bf"), - Value: types.StrPtr("1.2.3.6"), - Scope: types.StrPtr("Ip"), - Duration: types.StrPtr("24h"), - Type: types.StrPtr("ban"), + }, + Links: &modelscapi.GetDecisionsStreamResponseLinks{ + Blocklists: []*modelscapi.BlocklistLink{ + { + URL: types.StrPtr("http://api.crowdsec.net/blocklist1"), + Name: types.StrPtr("crowdsecurity/http-bf"), + Scope: types.StrPtr("Ip"), + Remediation: types.StrPtr("ban"), + Duration: types.StrPtr("24h"), + }, + { + URL: types.StrPtr("http://api.crowdsec.net/blocklist2"), + Name: types.StrPtr("crowdsecurity/ssh-bf"), + Scope: types.StrPtr("Ip"), + Remediation: types.StrPtr("ban"), + Duration: types.StrPtr("24h"), + }, }, - &models.Decision{ - Origin: types.StrPtr(types.ListOrigin), - Scenario: types.StrPtr("crowdsecurity/ssh-bf"), - Value: types.StrPtr("1.2.3.7"), - Scope: types.StrPtr("Ip"), - Duration: types.StrPtr("24h"), - Type: types.StrPtr("ban"), - }, // These two are from list subscription. }, }, ), )) + httpmock.RegisterResponder("GET", "http://api.crowdsec.net/blocklist1", httpmock.NewStringResponder( + 200, "1.2.3.6", + )) + httpmock.RegisterResponder("GET", "http://api.crowdsec.net/blocklist2", httpmock.NewStringResponder( + 200, "1.2.3.7", + )) url, err := url.ParseRequestURI("http://api.crowdsec.net/") require.NoError(t, err) @@ -845,15 +849,17 @@ func TestAPICPull(t *testing.T) { require.NoError(t, err) api.apiClient = apic httpmock.RegisterNoResponder(httpmock.NewBytesResponder(200, jsonMarshalX( - models.DecisionsStreamResponse{ - New: models.GetDecisionsResponse{ - &models.Decision{ - Origin: types.StrPtr(types.CAPIOrigin), - Scenario: types.StrPtr("crowdsecurity/test2"), - Value: types.StrPtr("1.2.3.5"), + modelscapi.GetDecisionsStreamResponse{ + New: modelscapi.GetDecisionsStreamResponseNew{ + &modelscapi.GetDecisionsStreamResponseNewItem{ + Scenario: types.StrPtr("crowdsecurity/ssh-bf"), Scope: types.StrPtr("Ip"), - Duration: types.StrPtr("24h"), - Type: types.StrPtr("ban"), + Decisions: []*modelscapi.GetDecisionsStreamResponseNewItemDecisionsItems0{ + { + Value: types.StrPtr("1.2.3.5"), + Duration: types.StrPtr("24h"), + }, + }, }, }, }, diff --git a/pkg/database/alerts.go b/pkg/database/alerts.go index b9d0de3a3..7133a4247 100644 --- a/pkg/database/alerts.go +++ b/pkg/database/alerts.go @@ -276,7 +276,10 @@ func (c *Client) CreateAlert(machineID string, alertList []*models.Alert) ([]str return ret, nil } -/*We can't bulk both the alert and the decision at the same time. With new consensus, we want to bulk a single alert with a lot of decisions.*/ +// UpdateCommunityBlocklist is called to update either the community blocklist (or other lists the user subscribed to) +// it takes care of creating the new alert with the associated decisions, and it will as well deleted the "older" overlapping decisions: +// 1st pull, you get decisions [1,2,3]. it inserts [1,2,3] +// 2nd pull, you get decisions [1,2,3,4]. it inserts [1,2,3,4] and will try to delete [1,2,3,4] with a different alert ID and same origin func (c *Client) UpdateCommunityBlocklist(alertItem *models.Alert) (int, int, int, error) { var err error diff --git a/pkg/modelscapi/add_signals_request.go b/pkg/modelscapi/add_signals_request.go new file mode 100644 index 000000000..62fe590cb --- /dev/null +++ b/pkg/modelscapi/add_signals_request.go @@ -0,0 +1,75 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// AddSignalsRequest add signals request +// +// # All signals request model +// +// swagger:model AddSignalsRequest +type AddSignalsRequest []*AddSignalsRequestItem + +// Validate validates this add signals request +func (m AddSignalsRequest) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + if swag.IsZero(m[i]) { // not required + continue + } + + if m[i] != nil { + if err := m[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// ContextValidate validate this add signals request based on the context it is used +func (m AddSignalsRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + + if m[i] != nil { + if err := m[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/pkg/modelscapi/add_signals_request_item.go b/pkg/modelscapi/add_signals_request_item.go new file mode 100644 index 000000000..f9c865b4c --- /dev/null +++ b/pkg/modelscapi/add_signals_request_item.go @@ -0,0 +1,361 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// AddSignalsRequestItem Signal +// +// swagger:model AddSignalsRequestItem +type AddSignalsRequestItem struct { + + // alert id + AlertID int64 `json:"alert_id,omitempty"` + + // context + Context []*AddSignalsRequestItemContextItems0 `json:"context"` + + // created at + CreatedAt string `json:"created_at,omitempty"` + + // decisions + Decisions AddSignalsRequestItemDecisions `json:"decisions,omitempty"` + + // machine id + MachineID string `json:"machine_id,omitempty"` + + // a human readable message + // Required: true + Message *string `json:"message"` + + // scenario + // Required: true + Scenario *string `json:"scenario"` + + // scenario hash + // Required: true + ScenarioHash *string `json:"scenario_hash"` + + // scenario trust + ScenarioTrust string `json:"scenario_trust,omitempty"` + + // scenario version + // Required: true + ScenarioVersion *string `json:"scenario_version"` + + // source + // Required: true + Source *AddSignalsRequestItemSource `json:"source"` + + // start at + // Required: true + StartAt *string `json:"start_at"` + + // stop at + // Required: true + StopAt *string `json:"stop_at"` +} + +// Validate validates this add signals request item +func (m *AddSignalsRequestItem) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateContext(formats); err != nil { + res = append(res, err) + } + + if err := m.validateDecisions(formats); err != nil { + res = append(res, err) + } + + if err := m.validateMessage(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScenario(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScenarioHash(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScenarioVersion(formats); err != nil { + res = append(res, err) + } + + if err := m.validateSource(formats); err != nil { + res = append(res, err) + } + + if err := m.validateStartAt(formats); err != nil { + res = append(res, err) + } + + if err := m.validateStopAt(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AddSignalsRequestItem) validateContext(formats strfmt.Registry) error { + if swag.IsZero(m.Context) { // not required + return nil + } + + for i := 0; i < len(m.Context); i++ { + if swag.IsZero(m.Context[i]) { // not required + continue + } + + if m.Context[i] != nil { + if err := m.Context[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("context" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("context" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +func (m *AddSignalsRequestItem) validateDecisions(formats strfmt.Registry) error { + if swag.IsZero(m.Decisions) { // not required + return nil + } + + if err := m.Decisions.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("decisions") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("decisions") + } + return err + } + + return nil +} + +func (m *AddSignalsRequestItem) validateMessage(formats strfmt.Registry) error { + + if err := validate.Required("message", "body", m.Message); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItem) validateScenario(formats strfmt.Registry) error { + + if err := validate.Required("scenario", "body", m.Scenario); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItem) validateScenarioHash(formats strfmt.Registry) error { + + if err := validate.Required("scenario_hash", "body", m.ScenarioHash); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItem) validateScenarioVersion(formats strfmt.Registry) error { + + if err := validate.Required("scenario_version", "body", m.ScenarioVersion); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItem) validateSource(formats strfmt.Registry) error { + + if err := validate.Required("source", "body", m.Source); err != nil { + return err + } + + if m.Source != nil { + if err := m.Source.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("source") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("source") + } + return err + } + } + + return nil +} + +func (m *AddSignalsRequestItem) validateStartAt(formats strfmt.Registry) error { + + if err := validate.Required("start_at", "body", m.StartAt); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItem) validateStopAt(formats strfmt.Registry) error { + + if err := validate.Required("stop_at", "body", m.StopAt); err != nil { + return err + } + + return nil +} + +// ContextValidate validate this add signals request item based on the context it is used +func (m *AddSignalsRequestItem) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + if err := m.contextValidateContext(ctx, formats); err != nil { + res = append(res, err) + } + + if err := m.contextValidateDecisions(ctx, formats); err != nil { + res = append(res, err) + } + + if err := m.contextValidateSource(ctx, formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AddSignalsRequestItem) contextValidateContext(ctx context.Context, formats strfmt.Registry) error { + + for i := 0; i < len(m.Context); i++ { + + if m.Context[i] != nil { + if err := m.Context[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("context" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("context" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +func (m *AddSignalsRequestItem) contextValidateDecisions(ctx context.Context, formats strfmt.Registry) error { + + if err := m.Decisions.ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("decisions") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("decisions") + } + return err + } + + return nil +} + +func (m *AddSignalsRequestItem) contextValidateSource(ctx context.Context, formats strfmt.Registry) error { + + if m.Source != nil { + if err := m.Source.ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("source") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("source") + } + return err + } + } + + return nil +} + +// MarshalBinary interface implementation +func (m *AddSignalsRequestItem) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AddSignalsRequestItem) UnmarshalBinary(b []byte) error { + var res AddSignalsRequestItem + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} + +// AddSignalsRequestItemContextItems0 add signals request item context items0 +// +// swagger:model AddSignalsRequestItemContextItems0 +type AddSignalsRequestItemContextItems0 struct { + + // key + Key string `json:"key,omitempty"` + + // value + Value string `json:"value,omitempty"` +} + +// Validate validates this add signals request item context items0 +func (m *AddSignalsRequestItemContextItems0) Validate(formats strfmt.Registry) error { + return nil +} + +// ContextValidate validates this add signals request item context items0 based on context it is used +func (m *AddSignalsRequestItemContextItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *AddSignalsRequestItemContextItems0) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AddSignalsRequestItemContextItems0) UnmarshalBinary(b []byte) error { + var res AddSignalsRequestItemContextItems0 + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/add_signals_request_item_decisions.go b/pkg/modelscapi/add_signals_request_item_decisions.go new file mode 100644 index 000000000..54e123ab3 --- /dev/null +++ b/pkg/modelscapi/add_signals_request_item_decisions.go @@ -0,0 +1,73 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// AddSignalsRequestItemDecisions Decisions list +// +// swagger:model AddSignalsRequestItemDecisions +type AddSignalsRequestItemDecisions []*AddSignalsRequestItemDecisionsItem + +// Validate validates this add signals request item decisions +func (m AddSignalsRequestItemDecisions) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + if swag.IsZero(m[i]) { // not required + continue + } + + if m[i] != nil { + if err := m[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// ContextValidate validate this add signals request item decisions based on the context it is used +func (m AddSignalsRequestItemDecisions) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + + if m[i] != nil { + if err := m[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/pkg/modelscapi/add_signals_request_item_decisions_item.go b/pkg/modelscapi/add_signals_request_item_decisions_item.go new file mode 100644 index 000000000..34dfeb5bc --- /dev/null +++ b/pkg/modelscapi/add_signals_request_item_decisions_item.go @@ -0,0 +1,179 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// AddSignalsRequestItemDecisionsItem Decision +// +// swagger:model AddSignalsRequestItemDecisionsItem +type AddSignalsRequestItemDecisionsItem struct { + + // duration + // Required: true + Duration *string `json:"duration"` + + // (only relevant for GET ops) the unique id + // Required: true + ID *int64 `json:"id"` + + // the origin of the decision : cscli, crowdsec + // Required: true + Origin *string `json:"origin"` + + // scenario + // Required: true + Scenario *string `json:"scenario"` + + // the scope of decision : does it apply to an IP, a range, a username, etc + // Required: true + Scope *string `json:"scope"` + + // simulated + Simulated bool `json:"simulated,omitempty"` + + // the type of decision, might be 'ban', 'captcha' or something custom. Ignored when watcher (cscli/crowdsec) is pushing to APIL. + // Required: true + Type *string `json:"type"` + + // until + Until string `json:"until,omitempty"` + + // the value of the decision scope : an IP, a range, a username, etc + // Required: true + Value *string `json:"value"` +} + +// Validate validates this add signals request item decisions item +func (m *AddSignalsRequestItemDecisionsItem) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateDuration(formats); err != nil { + res = append(res, err) + } + + if err := m.validateID(formats); err != nil { + res = append(res, err) + } + + if err := m.validateOrigin(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScenario(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScope(formats); err != nil { + res = append(res, err) + } + + if err := m.validateType(formats); err != nil { + res = append(res, err) + } + + if err := m.validateValue(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AddSignalsRequestItemDecisionsItem) validateDuration(formats strfmt.Registry) error { + + if err := validate.Required("duration", "body", m.Duration); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItemDecisionsItem) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItemDecisionsItem) validateOrigin(formats strfmt.Registry) error { + + if err := validate.Required("origin", "body", m.Origin); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItemDecisionsItem) validateScenario(formats strfmt.Registry) error { + + if err := validate.Required("scenario", "body", m.Scenario); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItemDecisionsItem) validateScope(formats strfmt.Registry) error { + + if err := validate.Required("scope", "body", m.Scope); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItemDecisionsItem) validateType(formats strfmt.Registry) error { + + if err := validate.Required("type", "body", m.Type); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItemDecisionsItem) validateValue(formats strfmt.Registry) error { + + if err := validate.Required("value", "body", m.Value); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this add signals request item decisions item based on context it is used +func (m *AddSignalsRequestItemDecisionsItem) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *AddSignalsRequestItemDecisionsItem) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AddSignalsRequestItemDecisionsItem) UnmarshalBinary(b []byte) error { + var res AddSignalsRequestItemDecisionsItem + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/add_signals_request_item_source.go b/pkg/modelscapi/add_signals_request_item_source.go new file mode 100644 index 000000000..6973e6854 --- /dev/null +++ b/pkg/modelscapi/add_signals_request_item_source.go @@ -0,0 +1,109 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// AddSignalsRequestItemSource Source +// +// swagger:model AddSignalsRequestItemSource +type AddSignalsRequestItemSource struct { + + // provided as a convenience when the source is an IP + AsName string `json:"as_name,omitempty"` + + // provided as a convenience when the source is an IP + AsNumber string `json:"as_number,omitempty"` + + // cn + Cn string `json:"cn,omitempty"` + + // provided as a convenience when the source is an IP + IP string `json:"ip,omitempty"` + + // latitude + Latitude float32 `json:"latitude,omitempty"` + + // longitude + Longitude float32 `json:"longitude,omitempty"` + + // provided as a convenience when the source is an IP + Range string `json:"range,omitempty"` + + // the scope of a source : ip,range,username,etc + // Required: true + Scope *string `json:"scope"` + + // the value of a source : the ip, the range, the username,etc + // Required: true + Value *string `json:"value"` +} + +// Validate validates this add signals request item source +func (m *AddSignalsRequestItemSource) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateScope(formats); err != nil { + res = append(res, err) + } + + if err := m.validateValue(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AddSignalsRequestItemSource) validateScope(formats strfmt.Registry) error { + + if err := validate.Required("scope", "body", m.Scope); err != nil { + return err + } + + return nil +} + +func (m *AddSignalsRequestItemSource) validateValue(formats strfmt.Registry) error { + + if err := validate.Required("value", "body", m.Value); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this add signals request item source based on context it is used +func (m *AddSignalsRequestItemSource) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *AddSignalsRequestItemSource) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AddSignalsRequestItemSource) UnmarshalBinary(b []byte) error { + var res AddSignalsRequestItemSource + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/blocklist_link.go b/pkg/modelscapi/blocklist_link.go new file mode 100644 index 000000000..fffa9b434 --- /dev/null +++ b/pkg/modelscapi/blocklist_link.go @@ -0,0 +1,139 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// BlocklistLink blocklist link +// +// swagger:model BlocklistLink +type BlocklistLink struct { + + // duration + // Required: true + Duration *string `json:"duration"` + + // the name of the blocklist + // Required: true + Name *string `json:"name"` + + // the remediation that should be used for the blocklist + // Required: true + Remediation *string `json:"remediation"` + + // the scope of decisions in the blocklist + // Required: true + Scope *string `json:"scope"` + + // the url from which the blocklist content can be downloaded + // Required: true + URL *string `json:"url"` +} + +// Validate validates this blocklist link +func (m *BlocklistLink) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateDuration(formats); err != nil { + res = append(res, err) + } + + if err := m.validateName(formats); err != nil { + res = append(res, err) + } + + if err := m.validateRemediation(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScope(formats); err != nil { + res = append(res, err) + } + + if err := m.validateURL(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *BlocklistLink) validateDuration(formats strfmt.Registry) error { + + if err := validate.Required("duration", "body", m.Duration); err != nil { + return err + } + + return nil +} + +func (m *BlocklistLink) validateName(formats strfmt.Registry) error { + + if err := validate.Required("name", "body", m.Name); err != nil { + return err + } + + return nil +} + +func (m *BlocklistLink) validateRemediation(formats strfmt.Registry) error { + + if err := validate.Required("remediation", "body", m.Remediation); err != nil { + return err + } + + return nil +} + +func (m *BlocklistLink) validateScope(formats strfmt.Registry) error { + + if err := validate.Required("scope", "body", m.Scope); err != nil { + return err + } + + return nil +} + +func (m *BlocklistLink) validateURL(formats strfmt.Registry) error { + + if err := validate.Required("url", "body", m.URL); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this blocklist link based on context it is used +func (m *BlocklistLink) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *BlocklistLink) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *BlocklistLink) UnmarshalBinary(b []byte) error { + var res BlocklistLink + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/decisions_delete_request.go b/pkg/modelscapi/decisions_delete_request.go new file mode 100644 index 000000000..e87188350 --- /dev/null +++ b/pkg/modelscapi/decisions_delete_request.go @@ -0,0 +1,67 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" +) + +// DecisionsDeleteRequest delete decisions +// +// delete decision model +// +// swagger:model DecisionsDeleteRequest +type DecisionsDeleteRequest []DecisionsDeleteRequestItem + +// Validate validates this decisions delete request +func (m DecisionsDeleteRequest) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + + if err := m[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// ContextValidate validate this decisions delete request based on the context it is used +func (m DecisionsDeleteRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + + if err := m[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/pkg/modelscapi/decisions_delete_request_item.go b/pkg/modelscapi/decisions_delete_request_item.go new file mode 100644 index 000000000..0aa81c065 --- /dev/null +++ b/pkg/modelscapi/decisions_delete_request_item.go @@ -0,0 +1,27 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/strfmt" +) + +// DecisionsDeleteRequestItem decisionsIDs +// +// swagger:model DecisionsDeleteRequestItem +type DecisionsDeleteRequestItem string + +// Validate validates this decisions delete request item +func (m DecisionsDeleteRequestItem) Validate(formats strfmt.Registry) error { + return nil +} + +// ContextValidate validates this decisions delete request item based on context it is used +func (m DecisionsDeleteRequestItem) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} diff --git a/pkg/modelscapi/decisions_sync_request.go b/pkg/modelscapi/decisions_sync_request.go new file mode 100644 index 000000000..e3a951625 --- /dev/null +++ b/pkg/modelscapi/decisions_sync_request.go @@ -0,0 +1,75 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// DecisionsSyncRequest sync decisions request +// +// sync decision model +// +// swagger:model DecisionsSyncRequest +type DecisionsSyncRequest []*DecisionsSyncRequestItem + +// Validate validates this decisions sync request +func (m DecisionsSyncRequest) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + if swag.IsZero(m[i]) { // not required + continue + } + + if m[i] != nil { + if err := m[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// ContextValidate validate this decisions sync request based on the context it is used +func (m DecisionsSyncRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + + if m[i] != nil { + if err := m[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/pkg/modelscapi/decisions_sync_request_item.go b/pkg/modelscapi/decisions_sync_request_item.go new file mode 100644 index 000000000..5139ea2de --- /dev/null +++ b/pkg/modelscapi/decisions_sync_request_item.go @@ -0,0 +1,263 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// DecisionsSyncRequestItem Signal +// +// swagger:model DecisionsSyncRequestItem +type DecisionsSyncRequestItem struct { + + // alert id + AlertID int64 `json:"alert_id,omitempty"` + + // created at + CreatedAt string `json:"created_at,omitempty"` + + // decisions + Decisions DecisionsSyncRequestItemDecisions `json:"decisions,omitempty"` + + // machine id + MachineID string `json:"machine_id,omitempty"` + + // a human readable message + // Required: true + Message *string `json:"message"` + + // scenario + // Required: true + Scenario *string `json:"scenario"` + + // scenario hash + // Required: true + ScenarioHash *string `json:"scenario_hash"` + + // scenario trust + ScenarioTrust string `json:"scenario_trust,omitempty"` + + // scenario version + // Required: true + ScenarioVersion *string `json:"scenario_version"` + + // source + // Required: true + Source *DecisionsSyncRequestItemSource `json:"source"` + + // start at + // Required: true + StartAt *string `json:"start_at"` + + // stop at + // Required: true + StopAt *string `json:"stop_at"` +} + +// Validate validates this decisions sync request item +func (m *DecisionsSyncRequestItem) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateDecisions(formats); err != nil { + res = append(res, err) + } + + if err := m.validateMessage(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScenario(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScenarioHash(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScenarioVersion(formats); err != nil { + res = append(res, err) + } + + if err := m.validateSource(formats); err != nil { + res = append(res, err) + } + + if err := m.validateStartAt(formats); err != nil { + res = append(res, err) + } + + if err := m.validateStopAt(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *DecisionsSyncRequestItem) validateDecisions(formats strfmt.Registry) error { + if swag.IsZero(m.Decisions) { // not required + return nil + } + + if err := m.Decisions.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("decisions") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("decisions") + } + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItem) validateMessage(formats strfmt.Registry) error { + + if err := validate.Required("message", "body", m.Message); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItem) validateScenario(formats strfmt.Registry) error { + + if err := validate.Required("scenario", "body", m.Scenario); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItem) validateScenarioHash(formats strfmt.Registry) error { + + if err := validate.Required("scenario_hash", "body", m.ScenarioHash); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItem) validateScenarioVersion(formats strfmt.Registry) error { + + if err := validate.Required("scenario_version", "body", m.ScenarioVersion); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItem) validateSource(formats strfmt.Registry) error { + + if err := validate.Required("source", "body", m.Source); err != nil { + return err + } + + if m.Source != nil { + if err := m.Source.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("source") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("source") + } + return err + } + } + + return nil +} + +func (m *DecisionsSyncRequestItem) validateStartAt(formats strfmt.Registry) error { + + if err := validate.Required("start_at", "body", m.StartAt); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItem) validateStopAt(formats strfmt.Registry) error { + + if err := validate.Required("stop_at", "body", m.StopAt); err != nil { + return err + } + + return nil +} + +// ContextValidate validate this decisions sync request item based on the context it is used +func (m *DecisionsSyncRequestItem) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + if err := m.contextValidateDecisions(ctx, formats); err != nil { + res = append(res, err) + } + + if err := m.contextValidateSource(ctx, formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *DecisionsSyncRequestItem) contextValidateDecisions(ctx context.Context, formats strfmt.Registry) error { + + if err := m.Decisions.ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("decisions") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("decisions") + } + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItem) contextValidateSource(ctx context.Context, formats strfmt.Registry) error { + + if m.Source != nil { + if err := m.Source.ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("source") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("source") + } + return err + } + } + + return nil +} + +// MarshalBinary interface implementation +func (m *DecisionsSyncRequestItem) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *DecisionsSyncRequestItem) UnmarshalBinary(b []byte) error { + var res DecisionsSyncRequestItem + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/decisions_sync_request_item_decisions.go b/pkg/modelscapi/decisions_sync_request_item_decisions.go new file mode 100644 index 000000000..76316e43c --- /dev/null +++ b/pkg/modelscapi/decisions_sync_request_item_decisions.go @@ -0,0 +1,73 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// DecisionsSyncRequestItemDecisions Decisions list +// +// swagger:model DecisionsSyncRequestItemDecisions +type DecisionsSyncRequestItemDecisions []*DecisionsSyncRequestItemDecisionsItem + +// Validate validates this decisions sync request item decisions +func (m DecisionsSyncRequestItemDecisions) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + if swag.IsZero(m[i]) { // not required + continue + } + + if m[i] != nil { + if err := m[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// ContextValidate validate this decisions sync request item decisions based on the context it is used +func (m DecisionsSyncRequestItemDecisions) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + + if m[i] != nil { + if err := m[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/pkg/modelscapi/decisions_sync_request_item_decisions_item.go b/pkg/modelscapi/decisions_sync_request_item_decisions_item.go new file mode 100644 index 000000000..31f05d8e3 --- /dev/null +++ b/pkg/modelscapi/decisions_sync_request_item_decisions_item.go @@ -0,0 +1,179 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// DecisionsSyncRequestItemDecisionsItem Decision +// +// swagger:model DecisionsSyncRequestItemDecisionsItem +type DecisionsSyncRequestItemDecisionsItem struct { + + // duration + // Required: true + Duration *string `json:"duration"` + + // (only relevant for GET ops) the unique id + // Required: true + ID *int64 `json:"id"` + + // the origin of the decision : cscli, crowdsec + // Required: true + Origin *string `json:"origin"` + + // scenario + // Required: true + Scenario *string `json:"scenario"` + + // the scope of decision : does it apply to an IP, a range, a username, etc + // Required: true + Scope *string `json:"scope"` + + // simulated + Simulated bool `json:"simulated,omitempty"` + + // the type of decision, might be 'ban', 'captcha' or something custom. Ignored when watcher (cscli/crowdsec) is pushing to APIL. + // Required: true + Type *string `json:"type"` + + // until + Until string `json:"until,omitempty"` + + // the value of the decision scope : an IP, a range, a username, etc + // Required: true + Value *string `json:"value"` +} + +// Validate validates this decisions sync request item decisions item +func (m *DecisionsSyncRequestItemDecisionsItem) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateDuration(formats); err != nil { + res = append(res, err) + } + + if err := m.validateID(formats); err != nil { + res = append(res, err) + } + + if err := m.validateOrigin(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScenario(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScope(formats); err != nil { + res = append(res, err) + } + + if err := m.validateType(formats); err != nil { + res = append(res, err) + } + + if err := m.validateValue(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *DecisionsSyncRequestItemDecisionsItem) validateDuration(formats strfmt.Registry) error { + + if err := validate.Required("duration", "body", m.Duration); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItemDecisionsItem) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItemDecisionsItem) validateOrigin(formats strfmt.Registry) error { + + if err := validate.Required("origin", "body", m.Origin); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItemDecisionsItem) validateScenario(formats strfmt.Registry) error { + + if err := validate.Required("scenario", "body", m.Scenario); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItemDecisionsItem) validateScope(formats strfmt.Registry) error { + + if err := validate.Required("scope", "body", m.Scope); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItemDecisionsItem) validateType(formats strfmt.Registry) error { + + if err := validate.Required("type", "body", m.Type); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItemDecisionsItem) validateValue(formats strfmt.Registry) error { + + if err := validate.Required("value", "body", m.Value); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this decisions sync request item decisions item based on context it is used +func (m *DecisionsSyncRequestItemDecisionsItem) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *DecisionsSyncRequestItemDecisionsItem) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *DecisionsSyncRequestItemDecisionsItem) UnmarshalBinary(b []byte) error { + var res DecisionsSyncRequestItemDecisionsItem + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/decisions_sync_request_item_source.go b/pkg/modelscapi/decisions_sync_request_item_source.go new file mode 100644 index 000000000..44f5f1f02 --- /dev/null +++ b/pkg/modelscapi/decisions_sync_request_item_source.go @@ -0,0 +1,109 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// DecisionsSyncRequestItemSource Source +// +// swagger:model DecisionsSyncRequestItemSource +type DecisionsSyncRequestItemSource struct { + + // provided as a convenience when the source is an IP + AsName string `json:"as_name,omitempty"` + + // provided as a convenience when the source is an IP + AsNumber string `json:"as_number,omitempty"` + + // cn + Cn string `json:"cn,omitempty"` + + // provided as a convenience when the source is an IP + IP string `json:"ip,omitempty"` + + // latitude + Latitude float32 `json:"latitude,omitempty"` + + // longitude + Longitude float32 `json:"longitude,omitempty"` + + // provided as a convenience when the source is an IP + Range string `json:"range,omitempty"` + + // the scope of a source : ip,range,username,etc + // Required: true + Scope *string `json:"scope"` + + // the value of a source : the ip, the range, the username,etc + // Required: true + Value *string `json:"value"` +} + +// Validate validates this decisions sync request item source +func (m *DecisionsSyncRequestItemSource) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateScope(formats); err != nil { + res = append(res, err) + } + + if err := m.validateValue(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *DecisionsSyncRequestItemSource) validateScope(formats strfmt.Registry) error { + + if err := validate.Required("scope", "body", m.Scope); err != nil { + return err + } + + return nil +} + +func (m *DecisionsSyncRequestItemSource) validateValue(formats strfmt.Registry) error { + + if err := validate.Required("value", "body", m.Value); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this decisions sync request item source based on context it is used +func (m *DecisionsSyncRequestItemSource) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *DecisionsSyncRequestItemSource) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *DecisionsSyncRequestItemSource) UnmarshalBinary(b []byte) error { + var res DecisionsSyncRequestItemSource + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/enroll_request.go b/pkg/modelscapi/enroll_request.go new file mode 100644 index 000000000..807bfff40 --- /dev/null +++ b/pkg/modelscapi/enroll_request.go @@ -0,0 +1,87 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// EnrollRequest enroll request +// +// enroll request model +// +// swagger:model EnrollRequest +type EnrollRequest struct { + + // attachment_key is generated in your crowdsec backoffice account and allows you to enroll your machines to your BO account + // Required: true + // Pattern: ^[a-zA-Z0-9]+$ + AttachmentKey *string `json:"attachment_key"` + + // The name that will be display in the console for the instance + Name string `json:"name,omitempty"` + + // To force enroll the instance + Overwrite bool `json:"overwrite,omitempty"` + + // Tags to apply on the console for the instance + Tags []string `json:"tags"` +} + +// Validate validates this enroll request +func (m *EnrollRequest) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateAttachmentKey(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *EnrollRequest) validateAttachmentKey(formats strfmt.Registry) error { + + if err := validate.Required("attachment_key", "body", m.AttachmentKey); err != nil { + return err + } + + if err := validate.Pattern("attachment_key", "body", *m.AttachmentKey, `^[a-zA-Z0-9]+$`); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this enroll request based on context it is used +func (m *EnrollRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *EnrollRequest) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *EnrollRequest) UnmarshalBinary(b []byte) error { + var res EnrollRequest + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/error_response.go b/pkg/modelscapi/error_response.go new file mode 100644 index 000000000..3bc8bd1ff --- /dev/null +++ b/pkg/modelscapi/error_response.go @@ -0,0 +1,76 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// ErrorResponse error response +// +// error response return by the API +// +// swagger:model ErrorResponse +type ErrorResponse struct { + + // more detail on individual errors + Errors string `json:"errors,omitempty"` + + // Error message + // Required: true + Message *string `json:"message"` +} + +// Validate validates this error response +func (m *ErrorResponse) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateMessage(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *ErrorResponse) validateMessage(formats strfmt.Registry) error { + + if err := validate.Required("message", "body", m.Message); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this error response based on context it is used +func (m *ErrorResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *ErrorResponse) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *ErrorResponse) UnmarshalBinary(b []byte) error { + var res ErrorResponse + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/get_decisions_stream_response.go b/pkg/modelscapi/get_decisions_stream_response.go new file mode 100644 index 000000000..af19b85c4 --- /dev/null +++ b/pkg/modelscapi/get_decisions_stream_response.go @@ -0,0 +1,190 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// GetDecisionsStreamResponse get decisions stream response +// +// get decision response model +// +// swagger:model GetDecisionsStreamResponse +type GetDecisionsStreamResponse struct { + + // deleted + Deleted GetDecisionsStreamResponseDeleted `json:"deleted,omitempty"` + + // links + Links *GetDecisionsStreamResponseLinks `json:"links,omitempty"` + + // new + New GetDecisionsStreamResponseNew `json:"new,omitempty"` +} + +// Validate validates this get decisions stream response +func (m *GetDecisionsStreamResponse) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateDeleted(formats); err != nil { + res = append(res, err) + } + + if err := m.validateLinks(formats); err != nil { + res = append(res, err) + } + + if err := m.validateNew(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *GetDecisionsStreamResponse) validateDeleted(formats strfmt.Registry) error { + if swag.IsZero(m.Deleted) { // not required + return nil + } + + if err := m.Deleted.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("deleted") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("deleted") + } + return err + } + + return nil +} + +func (m *GetDecisionsStreamResponse) validateLinks(formats strfmt.Registry) error { + if swag.IsZero(m.Links) { // not required + return nil + } + + if m.Links != nil { + if err := m.Links.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("links") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("links") + } + return err + } + } + + return nil +} + +func (m *GetDecisionsStreamResponse) validateNew(formats strfmt.Registry) error { + if swag.IsZero(m.New) { // not required + return nil + } + + if err := m.New.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("new") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("new") + } + return err + } + + return nil +} + +// ContextValidate validate this get decisions stream response based on the context it is used +func (m *GetDecisionsStreamResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + if err := m.contextValidateDeleted(ctx, formats); err != nil { + res = append(res, err) + } + + if err := m.contextValidateLinks(ctx, formats); err != nil { + res = append(res, err) + } + + if err := m.contextValidateNew(ctx, formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *GetDecisionsStreamResponse) contextValidateDeleted(ctx context.Context, formats strfmt.Registry) error { + + if err := m.Deleted.ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("deleted") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("deleted") + } + return err + } + + return nil +} + +func (m *GetDecisionsStreamResponse) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error { + + if m.Links != nil { + if err := m.Links.ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("links") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("links") + } + return err + } + } + + return nil +} + +func (m *GetDecisionsStreamResponse) contextValidateNew(ctx context.Context, formats strfmt.Registry) error { + + if err := m.New.ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("new") + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("new") + } + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *GetDecisionsStreamResponse) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *GetDecisionsStreamResponse) UnmarshalBinary(b []byte) error { + var res GetDecisionsStreamResponse + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/get_decisions_stream_response_deleted.go b/pkg/modelscapi/get_decisions_stream_response_deleted.go new file mode 100644 index 000000000..d218bf87e --- /dev/null +++ b/pkg/modelscapi/get_decisions_stream_response_deleted.go @@ -0,0 +1,73 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// GetDecisionsStreamResponseDeleted Decisions list +// +// swagger:model GetDecisionsStreamResponseDeleted +type GetDecisionsStreamResponseDeleted []*GetDecisionsStreamResponseDeletedItem + +// Validate validates this get decisions stream response deleted +func (m GetDecisionsStreamResponseDeleted) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + if swag.IsZero(m[i]) { // not required + continue + } + + if m[i] != nil { + if err := m[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// ContextValidate validate this get decisions stream response deleted based on the context it is used +func (m GetDecisionsStreamResponseDeleted) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + + if m[i] != nil { + if err := m[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/pkg/modelscapi/get_decisions_stream_response_deleted_item.go b/pkg/modelscapi/get_decisions_stream_response_deleted_item.go new file mode 100644 index 000000000..017211612 --- /dev/null +++ b/pkg/modelscapi/get_decisions_stream_response_deleted_item.go @@ -0,0 +1,88 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// GetDecisionsStreamResponseDeletedItem get decisions stream response deleted item +// +// swagger:model GetDecisionsStreamResponseDeletedItem +type GetDecisionsStreamResponseDeletedItem struct { + + // decisions + // Required: true + Decisions []string `json:"decisions"` + + // the scope of decision : does it apply to an IP, a range, a username, etc + // Required: true + Scope *string `json:"scope"` +} + +// Validate validates this get decisions stream response deleted item +func (m *GetDecisionsStreamResponseDeletedItem) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateDecisions(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScope(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *GetDecisionsStreamResponseDeletedItem) validateDecisions(formats strfmt.Registry) error { + + if err := validate.Required("decisions", "body", m.Decisions); err != nil { + return err + } + + return nil +} + +func (m *GetDecisionsStreamResponseDeletedItem) validateScope(formats strfmt.Registry) error { + + if err := validate.Required("scope", "body", m.Scope); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this get decisions stream response deleted item based on context it is used +func (m *GetDecisionsStreamResponseDeletedItem) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *GetDecisionsStreamResponseDeletedItem) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *GetDecisionsStreamResponseDeletedItem) UnmarshalBinary(b []byte) error { + var res GetDecisionsStreamResponseDeletedItem + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/get_decisions_stream_response_links.go b/pkg/modelscapi/get_decisions_stream_response_links.go new file mode 100644 index 000000000..85cc9af9b --- /dev/null +++ b/pkg/modelscapi/get_decisions_stream_response_links.go @@ -0,0 +1,116 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// GetDecisionsStreamResponseLinks Decisions list +// +// swagger:model GetDecisionsStreamResponseLinks +type GetDecisionsStreamResponseLinks struct { + + // blocklists + Blocklists []*BlocklistLink `json:"blocklists"` +} + +// Validate validates this get decisions stream response links +func (m *GetDecisionsStreamResponseLinks) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateBlocklists(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *GetDecisionsStreamResponseLinks) validateBlocklists(formats strfmt.Registry) error { + if swag.IsZero(m.Blocklists) { // not required + return nil + } + + for i := 0; i < len(m.Blocklists); i++ { + if swag.IsZero(m.Blocklists[i]) { // not required + continue + } + + if m.Blocklists[i] != nil { + if err := m.Blocklists[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("blocklists" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("blocklists" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +// ContextValidate validate this get decisions stream response links based on the context it is used +func (m *GetDecisionsStreamResponseLinks) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + if err := m.contextValidateBlocklists(ctx, formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *GetDecisionsStreamResponseLinks) contextValidateBlocklists(ctx context.Context, formats strfmt.Registry) error { + + for i := 0; i < len(m.Blocklists); i++ { + + if m.Blocklists[i] != nil { + if err := m.Blocklists[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("blocklists" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("blocklists" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +// MarshalBinary interface implementation +func (m *GetDecisionsStreamResponseLinks) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *GetDecisionsStreamResponseLinks) UnmarshalBinary(b []byte) error { + var res GetDecisionsStreamResponseLinks + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/get_decisions_stream_response_new.go b/pkg/modelscapi/get_decisions_stream_response_new.go new file mode 100644 index 000000000..e9525bf6f --- /dev/null +++ b/pkg/modelscapi/get_decisions_stream_response_new.go @@ -0,0 +1,73 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// GetDecisionsStreamResponseNew Decisions list +// +// swagger:model GetDecisionsStreamResponseNew +type GetDecisionsStreamResponseNew []*GetDecisionsStreamResponseNewItem + +// Validate validates this get decisions stream response new +func (m GetDecisionsStreamResponseNew) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + if swag.IsZero(m[i]) { // not required + continue + } + + if m[i] != nil { + if err := m[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// ContextValidate validate this get decisions stream response new based on the context it is used +func (m GetDecisionsStreamResponseNew) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + + if m[i] != nil { + if err := m[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/pkg/modelscapi/get_decisions_stream_response_new_item.go b/pkg/modelscapi/get_decisions_stream_response_new_item.go new file mode 100644 index 000000000..a3592d0ab --- /dev/null +++ b/pkg/modelscapi/get_decisions_stream_response_new_item.go @@ -0,0 +1,226 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// GetDecisionsStreamResponseNewItem New Decisions +// +// swagger:model GetDecisionsStreamResponseNewItem +type GetDecisionsStreamResponseNewItem struct { + + // decisions + // Required: true + Decisions []*GetDecisionsStreamResponseNewItemDecisionsItems0 `json:"decisions"` + + // scenario + // Required: true + Scenario *string `json:"scenario"` + + // the scope of decision : does it apply to an IP, a range, a username, etc + // Required: true + Scope *string `json:"scope"` +} + +// Validate validates this get decisions stream response new item +func (m *GetDecisionsStreamResponseNewItem) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateDecisions(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScenario(formats); err != nil { + res = append(res, err) + } + + if err := m.validateScope(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *GetDecisionsStreamResponseNewItem) validateDecisions(formats strfmt.Registry) error { + + if err := validate.Required("decisions", "body", m.Decisions); err != nil { + return err + } + + for i := 0; i < len(m.Decisions); i++ { + if swag.IsZero(m.Decisions[i]) { // not required + continue + } + + if m.Decisions[i] != nil { + if err := m.Decisions[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("decisions" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("decisions" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +func (m *GetDecisionsStreamResponseNewItem) validateScenario(formats strfmt.Registry) error { + + if err := validate.Required("scenario", "body", m.Scenario); err != nil { + return err + } + + return nil +} + +func (m *GetDecisionsStreamResponseNewItem) validateScope(formats strfmt.Registry) error { + + if err := validate.Required("scope", "body", m.Scope); err != nil { + return err + } + + return nil +} + +// ContextValidate validate this get decisions stream response new item based on the context it is used +func (m *GetDecisionsStreamResponseNewItem) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + if err := m.contextValidateDecisions(ctx, formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *GetDecisionsStreamResponseNewItem) contextValidateDecisions(ctx context.Context, formats strfmt.Registry) error { + + for i := 0; i < len(m.Decisions); i++ { + + if m.Decisions[i] != nil { + if err := m.Decisions[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("decisions" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("decisions" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +// MarshalBinary interface implementation +func (m *GetDecisionsStreamResponseNewItem) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *GetDecisionsStreamResponseNewItem) UnmarshalBinary(b []byte) error { + var res GetDecisionsStreamResponseNewItem + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} + +// GetDecisionsStreamResponseNewItemDecisionsItems0 get decisions stream response new item decisions items0 +// +// swagger:model GetDecisionsStreamResponseNewItemDecisionsItems0 +type GetDecisionsStreamResponseNewItemDecisionsItems0 struct { + + // duration + // Required: true + Duration *string `json:"duration"` + + // the value of the decision scope : an IP, a range, a username, etc + // Required: true + Value *string `json:"value"` +} + +// Validate validates this get decisions stream response new item decisions items0 +func (m *GetDecisionsStreamResponseNewItemDecisionsItems0) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateDuration(formats); err != nil { + res = append(res, err) + } + + if err := m.validateValue(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *GetDecisionsStreamResponseNewItemDecisionsItems0) validateDuration(formats strfmt.Registry) error { + + if err := validate.Required("duration", "body", m.Duration); err != nil { + return err + } + + return nil +} + +func (m *GetDecisionsStreamResponseNewItemDecisionsItems0) validateValue(formats strfmt.Registry) error { + + if err := validate.Required("value", "body", m.Value); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this get decisions stream response new item decisions items0 based on context it is used +func (m *GetDecisionsStreamResponseNewItemDecisionsItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *GetDecisionsStreamResponseNewItemDecisionsItems0) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *GetDecisionsStreamResponseNewItemDecisionsItems0) UnmarshalBinary(b []byte) error { + var res GetDecisionsStreamResponseNewItemDecisionsItems0 + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/login_request.go b/pkg/modelscapi/login_request.go new file mode 100644 index 000000000..b506f6fea --- /dev/null +++ b/pkg/modelscapi/login_request.go @@ -0,0 +1,108 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// LoginRequest login request +// +// # Login request model +// +// swagger:model LoginRequest +type LoginRequest struct { + + // machine_id is a (username) generated by crowdsec + // Required: true + // Max Length: 48 + // Min Length: 48 + // Pattern: ^[a-zA-Z0-9]+$ + MachineID *string `json:"machine_id"` + + // Password, should respect the password policy (link to add) + // Required: true + Password *string `json:"password"` + + // all scenarios installed + Scenarios []string `json:"scenarios"` +} + +// Validate validates this login request +func (m *LoginRequest) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateMachineID(formats); err != nil { + res = append(res, err) + } + + if err := m.validatePassword(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *LoginRequest) validateMachineID(formats strfmt.Registry) error { + + if err := validate.Required("machine_id", "body", m.MachineID); err != nil { + return err + } + + if err := validate.MinLength("machine_id", "body", *m.MachineID, 48); err != nil { + return err + } + + if err := validate.MaxLength("machine_id", "body", *m.MachineID, 48); err != nil { + return err + } + + if err := validate.Pattern("machine_id", "body", *m.MachineID, `^[a-zA-Z0-9]+$`); err != nil { + return err + } + + return nil +} + +func (m *LoginRequest) validatePassword(formats strfmt.Registry) error { + + if err := validate.Required("password", "body", m.Password); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this login request based on context it is used +func (m *LoginRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *LoginRequest) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *LoginRequest) UnmarshalBinary(b []byte) error { + var res LoginRequest + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/login_response.go b/pkg/modelscapi/login_response.go new file mode 100644 index 000000000..baa33ad5d --- /dev/null +++ b/pkg/modelscapi/login_response.go @@ -0,0 +1,58 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// LoginResponse login response +// +// # Login request model +// +// swagger:model LoginResponse +type LoginResponse struct { + + // code + Code int64 `json:"code,omitempty"` + + // expire + Expire string `json:"expire,omitempty"` + + // token + Token string `json:"token,omitempty"` +} + +// Validate validates this login response +func (m *LoginResponse) Validate(formats strfmt.Registry) error { + return nil +} + +// ContextValidate validates this login response based on context it is used +func (m *LoginResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *LoginResponse) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *LoginResponse) UnmarshalBinary(b []byte) error { + var res LoginResponse + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/metrics_request.go b/pkg/modelscapi/metrics_request.go new file mode 100644 index 000000000..d5b7d058f --- /dev/null +++ b/pkg/modelscapi/metrics_request.go @@ -0,0 +1,180 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// MetricsRequest metrics +// +// push metrics model +// +// swagger:model MetricsRequest +type MetricsRequest struct { + + // bouncers + // Required: true + Bouncers []*MetricsRequestBouncersItem `json:"bouncers"` + + // machines + // Required: true + Machines []*MetricsRequestMachinesItem `json:"machines"` +} + +// Validate validates this metrics request +func (m *MetricsRequest) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateBouncers(formats); err != nil { + res = append(res, err) + } + + if err := m.validateMachines(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *MetricsRequest) validateBouncers(formats strfmt.Registry) error { + + if err := validate.Required("bouncers", "body", m.Bouncers); err != nil { + return err + } + + for i := 0; i < len(m.Bouncers); i++ { + if swag.IsZero(m.Bouncers[i]) { // not required + continue + } + + if m.Bouncers[i] != nil { + if err := m.Bouncers[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("bouncers" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("bouncers" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +func (m *MetricsRequest) validateMachines(formats strfmt.Registry) error { + + if err := validate.Required("machines", "body", m.Machines); err != nil { + return err + } + + for i := 0; i < len(m.Machines); i++ { + if swag.IsZero(m.Machines[i]) { // not required + continue + } + + if m.Machines[i] != nil { + if err := m.Machines[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("machines" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("machines" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +// ContextValidate validate this metrics request based on the context it is used +func (m *MetricsRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + if err := m.contextValidateBouncers(ctx, formats); err != nil { + res = append(res, err) + } + + if err := m.contextValidateMachines(ctx, formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *MetricsRequest) contextValidateBouncers(ctx context.Context, formats strfmt.Registry) error { + + for i := 0; i < len(m.Bouncers); i++ { + + if m.Bouncers[i] != nil { + if err := m.Bouncers[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("bouncers" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("bouncers" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +func (m *MetricsRequest) contextValidateMachines(ctx context.Context, formats strfmt.Registry) error { + + for i := 0; i < len(m.Machines); i++ { + + if m.Machines[i] != nil { + if err := m.Machines[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("machines" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("machines" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +// MarshalBinary interface implementation +func (m *MetricsRequest) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *MetricsRequest) UnmarshalBinary(b []byte) error { + var res MetricsRequest + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/metrics_request_bouncers_item.go b/pkg/modelscapi/metrics_request_bouncers_item.go new file mode 100644 index 000000000..51b067ca5 --- /dev/null +++ b/pkg/modelscapi/metrics_request_bouncers_item.go @@ -0,0 +1,59 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// MetricsRequestBouncersItem MetricsBouncerInfo +// +// swagger:model MetricsRequestBouncersItem +type MetricsRequestBouncersItem struct { + + // bouncer name + CustomName string `json:"custom_name,omitempty"` + + // last bouncer pull date + LastPull string `json:"last_pull,omitempty"` + + // bouncer type (firewall, php...) + Name string `json:"name,omitempty"` + + // bouncer version + Version string `json:"version,omitempty"` +} + +// Validate validates this metrics request bouncers item +func (m *MetricsRequestBouncersItem) Validate(formats strfmt.Registry) error { + return nil +} + +// ContextValidate validates this metrics request bouncers item based on context it is used +func (m *MetricsRequestBouncersItem) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *MetricsRequestBouncersItem) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *MetricsRequestBouncersItem) UnmarshalBinary(b []byte) error { + var res MetricsRequestBouncersItem + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/metrics_request_machines_item.go b/pkg/modelscapi/metrics_request_machines_item.go new file mode 100644 index 000000000..d86602853 --- /dev/null +++ b/pkg/modelscapi/metrics_request_machines_item.go @@ -0,0 +1,59 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// MetricsRequestMachinesItem MetricsAgentInfo +// +// swagger:model MetricsRequestMachinesItem +type MetricsRequestMachinesItem struct { + + // last agent push date + LastPush string `json:"last_push,omitempty"` + + // last agent update date + LastUpdate string `json:"last_update,omitempty"` + + // agent name + Name string `json:"name,omitempty"` + + // agent version + Version string `json:"version,omitempty"` +} + +// Validate validates this metrics request machines item +func (m *MetricsRequestMachinesItem) Validate(formats strfmt.Registry) error { + return nil +} + +// ContextValidate validates this metrics request machines item based on context it is used +func (m *MetricsRequestMachinesItem) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *MetricsRequestMachinesItem) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *MetricsRequestMachinesItem) UnmarshalBinary(b []byte) error { + var res MetricsRequestMachinesItem + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/register_request.go b/pkg/modelscapi/register_request.go new file mode 100644 index 000000000..4c4813d7e --- /dev/null +++ b/pkg/modelscapi/register_request.go @@ -0,0 +1,95 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// RegisterRequest register request +// +// # Register request model +// +// swagger:model RegisterRequest +type RegisterRequest struct { + + // machine_id is a (username) generated by crowdsec + // Required: true + // Pattern: ^[a-zA-Z0-9]+$ + MachineID *string `json:"machine_id"` + + // Password, should respect the password policy (link to add) + // Required: true + Password *string `json:"password"` +} + +// Validate validates this register request +func (m *RegisterRequest) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateMachineID(formats); err != nil { + res = append(res, err) + } + + if err := m.validatePassword(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *RegisterRequest) validateMachineID(formats strfmt.Registry) error { + + if err := validate.Required("machine_id", "body", m.MachineID); err != nil { + return err + } + + if err := validate.Pattern("machine_id", "body", *m.MachineID, `^[a-zA-Z0-9]+$`); err != nil { + return err + } + + return nil +} + +func (m *RegisterRequest) validatePassword(formats strfmt.Registry) error { + + if err := validate.Required("password", "body", m.Password); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this register request based on context it is used +func (m *RegisterRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *RegisterRequest) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *RegisterRequest) UnmarshalBinary(b []byte) error { + var res RegisterRequest + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/reset_password_request.go b/pkg/modelscapi/reset_password_request.go new file mode 100644 index 000000000..571abd695 --- /dev/null +++ b/pkg/modelscapi/reset_password_request.go @@ -0,0 +1,105 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// ResetPasswordRequest resetPassword +// +// # ResetPassword request model +// +// swagger:model ResetPasswordRequest +type ResetPasswordRequest struct { + + // machine_id is a (username) generated by crowdsec + // Required: true + // Max Length: 48 + // Min Length: 48 + // Pattern: ^[a-zA-Z0-9]+$ + MachineID *string `json:"machine_id"` + + // Password, should respect the password policy (link to add) + // Required: true + Password *string `json:"password"` +} + +// Validate validates this reset password request +func (m *ResetPasswordRequest) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateMachineID(formats); err != nil { + res = append(res, err) + } + + if err := m.validatePassword(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *ResetPasswordRequest) validateMachineID(formats strfmt.Registry) error { + + if err := validate.Required("machine_id", "body", m.MachineID); err != nil { + return err + } + + if err := validate.MinLength("machine_id", "body", *m.MachineID, 48); err != nil { + return err + } + + if err := validate.MaxLength("machine_id", "body", *m.MachineID, 48); err != nil { + return err + } + + if err := validate.Pattern("machine_id", "body", *m.MachineID, `^[a-zA-Z0-9]+$`); err != nil { + return err + } + + return nil +} + +func (m *ResetPasswordRequest) validatePassword(formats strfmt.Registry) error { + + if err := validate.Required("password", "body", m.Password); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this reset password request based on context it is used +func (m *ResetPasswordRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *ResetPasswordRequest) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *ResetPasswordRequest) UnmarshalBinary(b []byte) error { + var res ResetPasswordRequest + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/modelscapi/success_response.go b/pkg/modelscapi/success_response.go new file mode 100644 index 000000000..a5599bb87 --- /dev/null +++ b/pkg/modelscapi/success_response.go @@ -0,0 +1,73 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package modelscapi + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// SuccessResponse success response +// +// success response return by the API +// +// swagger:model SuccessResponse +type SuccessResponse struct { + + // message + // Required: true + Message *string `json:"message"` +} + +// Validate validates this success response +func (m *SuccessResponse) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateMessage(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *SuccessResponse) validateMessage(formats strfmt.Registry) error { + + if err := validate.Required("message", "body", m.Message); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this success response based on context it is used +func (m *SuccessResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *SuccessResponse) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *SuccessResponse) UnmarshalBinary(b []byte) error { + var res SuccessResponse + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/types/constants.go b/pkg/types/constants.go index 2ee26d6c2..4e0d445c4 100644 --- a/pkg/types/constants.go +++ b/pkg/types/constants.go @@ -14,6 +14,8 @@ const CscliImportOrigin = "cscli-import" const ListOrigin = "lists" const CAPIOrigin = "CAPI" +const DecisionTypeBan = "ban" + func GetOrigins() []string { return []string{ CscliOrigin,