ocket8888 commented on code in PR #7213:
URL: https://github.com/apache/trafficcontrol/pull/7213#discussion_r1049951099
##########
traffic_ops/traffic_ops_golang/dbhelpers/db_helpers.go:
##########
@@ -2184,3 +2184,18 @@ func GetProfileIDDesc(tx *sql.Tx, name string) (id int,
desc string) {
}
return
}
+
+// GetSCInfo confirms whether the server capability exists, and an error (if
one occurs).
+func GetSCInfo(tx *sqlx.Tx, name string) (bool, error) {
+ var count int
+ if err := tx.QueryRow("SELECT count(name) FROM server_capability AS sc
WHERE sc.name=$1", name).Scan(&count); err != nil {
+ return false, fmt.Errorf("getting server capability info: %v",
err)
Review Comment:
formatting a source error should use `%w` to wrap it
##########
traffic_ops/traffic_ops_golang/servercapability/servercapability.go:
##########
@@ -151,6 +153,202 @@ func (v *TOServerCapability) Update(h http.Header)
(error, error, int) {
return nil, nil, http.StatusOK
}
+func GetServerCapability(w http.ResponseWriter, r *http.Request) {
+ var sc tc.ServerCapabilityV4
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ tx := inf.Tx
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ // Query Parameters to Database Query column mappings
+ queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{
+ "name": {Column: "sc.name", Checker: nil},
+ }
+ if _, ok := inf.Params["orderby"]; !ok {
+ inf.Params["orderby"] = "name"
+ }
+ where, orderBy, pagination, queryValues, errs :=
dbhelpers.BuildWhereAndOrderByAndPagination(inf.Params, queryParamsToQueryCols)
+ if len(errs) > 0 {
+ api.HandleErr(w, r, tx.Tx, http.StatusBadRequest,
util.JoinErrs(errs), nil)
+ return
+ }
+
+ selectQuery := "SELECT name, description, last_updated FROM
server_capability sc"
+ query := selectQuery + where + orderBy + pagination
+ rows, err := tx.NamedQuery(query, queryValues)
+ if err != nil {
+ api.HandleErr(w, r, tx.Tx, http.StatusInternalServerError, nil,
fmt.Errorf("server capability read: error getting server capability(ies): %w",
err))
+ return
+ }
+ defer log.Close(rows, "unable to close DB connection")
+
+ scList := []tc.ServerCapabilityV4{}
+ for rows.Next() {
+ if err = rows.Scan(&sc.Name, &sc.Description, &sc.LastUpdated);
err != nil {
+ api.HandleErr(w, r, tx.Tx,
http.StatusInternalServerError, nil, fmt.Errorf("error getting server
capability(ies): %w", err))
+ return
+ }
+ scList = append(scList, sc)
+ }
+
+ api.WriteResp(w, r, scList)
+ return
+}
+
+func UpdateServerCapability(w http.ResponseWriter, r *http.Request) {
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ tx := inf.Tx.Tx
+ sc, readValErr := readAndValidateJsonStruct(r)
+ if readValErr != nil {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil)
+ return
+ }
+
+ requestedName := inf.Params["name"]
+ // check if the entity was already updated
+ userErr, sysErr, errCode = api.CheckIfUnModifiedByName(r.Header,
inf.Tx, requestedName, "server_capability")
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx, errCode, userErr, sysErr)
+ return
+ }
+
+ //update name and description of a capability
+ query := `UPDATE server_capability sc SET
+ name = $1,
+ description = $2
+ WHERE sc.name = $3
+ RETURNING sc.name, sc.description, sc.last_updated`
+
+ err := tx.QueryRow(query, sc.Name, sc.Description,
requestedName).Scan(&sc.Name, &sc.Description, &sc.LastUpdated)
+ if err != nil && err == sql.ErrNoRows {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, err, nil)
+ return
+ }
Review Comment:
This ignores all errors that aren't exactly `sql.ErrNoRows`. Ithink you
should just check if the error is nil and use `api.ParseDBError` instead.
##########
traffic_ops/traffic_ops_golang/servercapability/servercapability.go:
##########
@@ -151,6 +153,202 @@ func (v *TOServerCapability) Update(h http.Header)
(error, error, int) {
return nil, nil, http.StatusOK
}
+func GetServerCapability(w http.ResponseWriter, r *http.Request) {
+ var sc tc.ServerCapabilityV4
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ tx := inf.Tx
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ // Query Parameters to Database Query column mappings
+ queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{
+ "name": {Column: "sc.name", Checker: nil},
+ }
+ if _, ok := inf.Params["orderby"]; !ok {
+ inf.Params["orderby"] = "name"
+ }
+ where, orderBy, pagination, queryValues, errs :=
dbhelpers.BuildWhereAndOrderByAndPagination(inf.Params, queryParamsToQueryCols)
+ if len(errs) > 0 {
+ api.HandleErr(w, r, tx.Tx, http.StatusBadRequest,
util.JoinErrs(errs), nil)
+ return
+ }
+
+ selectQuery := "SELECT name, description, last_updated FROM
server_capability sc"
+ query := selectQuery + where + orderBy + pagination
+ rows, err := tx.NamedQuery(query, queryValues)
+ if err != nil {
+ api.HandleErr(w, r, tx.Tx, http.StatusInternalServerError, nil,
fmt.Errorf("server capability read: error getting server capability(ies): %w",
err))
+ return
+ }
+ defer log.Close(rows, "unable to close DB connection")
+
+ scList := []tc.ServerCapabilityV4{}
+ for rows.Next() {
+ if err = rows.Scan(&sc.Name, &sc.Description, &sc.LastUpdated);
err != nil {
+ api.HandleErr(w, r, tx.Tx,
http.StatusInternalServerError, nil, fmt.Errorf("error getting server
capability(ies): %w", err))
+ return
+ }
+ scList = append(scList, sc)
+ }
+
+ api.WriteResp(w, r, scList)
+ return
+}
+
+func UpdateServerCapability(w http.ResponseWriter, r *http.Request) {
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ tx := inf.Tx.Tx
+ sc, readValErr := readAndValidateJsonStruct(r)
+ if readValErr != nil {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil)
+ return
+ }
+
+ requestedName := inf.Params["name"]
+ // check if the entity was already updated
+ userErr, sysErr, errCode = api.CheckIfUnModifiedByName(r.Header,
inf.Tx, requestedName, "server_capability")
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx, errCode, userErr, sysErr)
+ return
+ }
+
+ //update name and description of a capability
+ query := `UPDATE server_capability sc SET
+ name = $1,
+ description = $2
+ WHERE sc.name = $3
+ RETURNING sc.name, sc.description, sc.last_updated`
+
+ err := tx.QueryRow(query, sc.Name, sc.Description,
requestedName).Scan(&sc.Name, &sc.Description, &sc.LastUpdated)
+ if err != nil && err == sql.ErrNoRows {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, err, nil)
+ return
+ }
+ alerts := tc.CreateAlerts(tc.SuccessLevel, "server capability was
updated")
+ api.WriteAlertsObj(w, r, http.StatusOK, alerts, sc)
+ return
+}
+
+func CreateServerCapability(w http.ResponseWriter, r *http.Request) {
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+ tx := inf.Tx.Tx
+
+ sc, readValErr := readAndValidateJsonStruct(r)
+ if readValErr != nil {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil)
+ return
+ }
+
+ // check if capability already exists
+ var count int
+ err := tx.QueryRow("SELECT count(*) from server_capability where name =
$1", sc.Name).Scan(&count)
+ if err != nil {
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
fmt.Errorf("checking if server capability with name %s exists", sc.Name))
Review Comment:
I think you meant to include the `err` in this `fmt.Errorf` call but forgot
to
##########
traffic_ops/traffic_ops_golang/servercapability/servercapability.go:
##########
@@ -151,6 +153,202 @@ func (v *TOServerCapability) Update(h http.Header)
(error, error, int) {
return nil, nil, http.StatusOK
}
+func GetServerCapability(w http.ResponseWriter, r *http.Request) {
+ var sc tc.ServerCapabilityV4
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ tx := inf.Tx
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ // Query Parameters to Database Query column mappings
+ queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{
+ "name": {Column: "sc.name", Checker: nil},
+ }
+ if _, ok := inf.Params["orderby"]; !ok {
+ inf.Params["orderby"] = "name"
+ }
+ where, orderBy, pagination, queryValues, errs :=
dbhelpers.BuildWhereAndOrderByAndPagination(inf.Params, queryParamsToQueryCols)
+ if len(errs) > 0 {
+ api.HandleErr(w, r, tx.Tx, http.StatusBadRequest,
util.JoinErrs(errs), nil)
+ return
+ }
+
+ selectQuery := "SELECT name, description, last_updated FROM
server_capability sc"
+ query := selectQuery + where + orderBy + pagination
+ rows, err := tx.NamedQuery(query, queryValues)
+ if err != nil {
+ api.HandleErr(w, r, tx.Tx, http.StatusInternalServerError, nil,
fmt.Errorf("server capability read: error getting server capability(ies): %w",
err))
+ return
+ }
+ defer log.Close(rows, "unable to close DB connection")
+
+ scList := []tc.ServerCapabilityV4{}
+ for rows.Next() {
+ if err = rows.Scan(&sc.Name, &sc.Description, &sc.LastUpdated);
err != nil {
+ api.HandleErr(w, r, tx.Tx,
http.StatusInternalServerError, nil, fmt.Errorf("error getting server
capability(ies): %w", err))
+ return
+ }
+ scList = append(scList, sc)
+ }
+
+ api.WriteResp(w, r, scList)
+ return
+}
+
+func UpdateServerCapability(w http.ResponseWriter, r *http.Request) {
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ tx := inf.Tx.Tx
+ sc, readValErr := readAndValidateJsonStruct(r)
+ if readValErr != nil {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil)
+ return
+ }
+
+ requestedName := inf.Params["name"]
+ // check if the entity was already updated
+ userErr, sysErr, errCode = api.CheckIfUnModifiedByName(r.Header,
inf.Tx, requestedName, "server_capability")
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx, errCode, userErr, sysErr)
+ return
+ }
+
+ //update name and description of a capability
+ query := `UPDATE server_capability sc SET
+ name = $1,
+ description = $2
+ WHERE sc.name = $3
+ RETURNING sc.name, sc.description, sc.last_updated`
+
+ err := tx.QueryRow(query, sc.Name, sc.Description,
requestedName).Scan(&sc.Name, &sc.Description, &sc.LastUpdated)
+ if err != nil && err == sql.ErrNoRows {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, err, nil)
+ return
+ }
+ alerts := tc.CreateAlerts(tc.SuccessLevel, "server capability was
updated")
+ api.WriteAlertsObj(w, r, http.StatusOK, alerts, sc)
+ return
+}
+
+func CreateServerCapability(w http.ResponseWriter, r *http.Request) {
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+ tx := inf.Tx.Tx
+
+ sc, readValErr := readAndValidateJsonStruct(r)
+ if readValErr != nil {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil)
+ return
+ }
+
+ // check if capability already exists
+ var count int
+ err := tx.QueryRow("SELECT count(*) from server_capability where name =
$1", sc.Name).Scan(&count)
+ if err != nil {
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
fmt.Errorf("checking if server capability with name %s exists", sc.Name))
+ return
+ }
+ if count == 1 {
+ api.HandleErr(w, r, tx, http.StatusBadRequest,
fmt.Errorf("server_capability name '%s' already exists.", sc.Name), nil)
+ return
+ }
+
+ // create server capability
+ query := `INSERT INTO server_capability (name, description) VALUES ($1,
$2) RETURNING last_updated`
+ err = tx.QueryRow(query, sc.Name, sc.Description).Scan(&sc.LastUpdated)
+ if err != nil && err == sql.ErrNoRows {
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
err)
+ return
+ }
+ alerts := tc.CreateAlerts(tc.SuccessLevel, "server capability was
created.")
+ api.WriteAlertsObj(w, r, http.StatusOK, alerts, sc)
Review Comment:
The response for a successful creation should be `201 Created` with a
`Location` header set to a URL (absolute or relative but relative is way
simpler) to which a GET request can be sent to retrieve a representation of the
created object.
##########
traffic_ops/traffic_ops_golang/servercapability/servercapability.go:
##########
@@ -151,6 +153,202 @@ func (v *TOServerCapability) Update(h http.Header)
(error, error, int) {
return nil, nil, http.StatusOK
}
+func GetServerCapability(w http.ResponseWriter, r *http.Request) {
+ var sc tc.ServerCapabilityV4
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ tx := inf.Tx
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ // Query Parameters to Database Query column mappings
+ queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{
+ "name": {Column: "sc.name", Checker: nil},
+ }
+ if _, ok := inf.Params["orderby"]; !ok {
+ inf.Params["orderby"] = "name"
+ }
+ where, orderBy, pagination, queryValues, errs :=
dbhelpers.BuildWhereAndOrderByAndPagination(inf.Params, queryParamsToQueryCols)
+ if len(errs) > 0 {
+ api.HandleErr(w, r, tx.Tx, http.StatusBadRequest,
util.JoinErrs(errs), nil)
+ return
+ }
+
+ selectQuery := "SELECT name, description, last_updated FROM
server_capability sc"
+ query := selectQuery + where + orderBy + pagination
+ rows, err := tx.NamedQuery(query, queryValues)
+ if err != nil {
+ api.HandleErr(w, r, tx.Tx, http.StatusInternalServerError, nil,
fmt.Errorf("server capability read: error getting server capability(ies): %w",
err))
+ return
+ }
+ defer log.Close(rows, "unable to close DB connection")
+
+ scList := []tc.ServerCapabilityV4{}
+ for rows.Next() {
+ if err = rows.Scan(&sc.Name, &sc.Description, &sc.LastUpdated);
err != nil {
+ api.HandleErr(w, r, tx.Tx,
http.StatusInternalServerError, nil, fmt.Errorf("error getting server
capability(ies): %w", err))
+ return
+ }
+ scList = append(scList, sc)
+ }
+
+ api.WriteResp(w, r, scList)
+ return
+}
+
+func UpdateServerCapability(w http.ResponseWriter, r *http.Request) {
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ tx := inf.Tx.Tx
+ sc, readValErr := readAndValidateJsonStruct(r)
+ if readValErr != nil {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil)
+ return
+ }
+
+ requestedName := inf.Params["name"]
+ // check if the entity was already updated
+ userErr, sysErr, errCode = api.CheckIfUnModifiedByName(r.Header,
inf.Tx, requestedName, "server_capability")
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx, errCode, userErr, sysErr)
+ return
+ }
+
+ //update name and description of a capability
+ query := `UPDATE server_capability sc SET
+ name = $1,
+ description = $2
+ WHERE sc.name = $3
+ RETURNING sc.name, sc.description, sc.last_updated`
+
+ err := tx.QueryRow(query, sc.Name, sc.Description,
requestedName).Scan(&sc.Name, &sc.Description, &sc.LastUpdated)
+ if err != nil && err == sql.ErrNoRows {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, err, nil)
+ return
+ }
+ alerts := tc.CreateAlerts(tc.SuccessLevel, "server capability was
updated")
+ api.WriteAlertsObj(w, r, http.StatusOK, alerts, sc)
+ return
+}
+
+func CreateServerCapability(w http.ResponseWriter, r *http.Request) {
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+ tx := inf.Tx.Tx
+
+ sc, readValErr := readAndValidateJsonStruct(r)
+ if readValErr != nil {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil)
+ return
+ }
+
+ // check if capability already exists
+ var count int
+ err := tx.QueryRow("SELECT count(*) from server_capability where name =
$1", sc.Name).Scan(&count)
+ if err != nil {
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
fmt.Errorf("checking if server capability with name %s exists", sc.Name))
+ return
+ }
+ if count == 1 {
+ api.HandleErr(w, r, tx, http.StatusBadRequest,
fmt.Errorf("server_capability name '%s' already exists.", sc.Name), nil)
+ return
+ }
+
+ // create server capability
+ query := `INSERT INTO server_capability (name, description) VALUES ($1,
$2) RETURNING last_updated`
+ err = tx.QueryRow(query, sc.Name, sc.Description).Scan(&sc.LastUpdated)
+ if err != nil && err == sql.ErrNoRows {
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
err)
+ return
+ }
+ alerts := tc.CreateAlerts(tc.SuccessLevel, "server capability was
created.")
+ api.WriteAlertsObj(w, r, http.StatusOK, alerts, sc)
+ return
+}
+
+func DeleteServerCapability(w http.ResponseWriter, r *http.Request) {
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ tx := inf.Tx.Tx
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ name := inf.Params["name"]
+ exists, err := dbhelpers.GetSCInfo(inf.Tx, name)
+ if err != nil {
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
err)
+ return
+ }
+ if !exists {
+ if name != "" {
+ api.HandleErr(w, r, tx, http.StatusNotFound,
fmt.Errorf("no server capability exists by name: %s", name), nil)
+ return
+ } else {
+ api.HandleErr(w, r, tx, http.StatusBadRequest,
fmt.Errorf("no server capability exists for empty name: %s", name), nil)
+ return
+ }
+ }
+
+ assignedServer := 0
+ if err := inf.Tx.Get(&assignedServer, "SELECT count(server) FROM
server_server_capability ssc WHERE ssc.server_capability=$1", name); err != nil
{
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
fmt.Errorf("server capability delete, counting assigned servers: %w", err))
+ return
+ } else if assignedServer != 0 {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("can
not delete a server capability with %d assigned servers", assignedServer), nil)
+ return
+ }
+
+ res, err := tx.Exec("DELETE FROM server_capability AS sc WHERE
sc.name=$1", name)
+ if err != nil {
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
err)
+ return
+ }
+ rowsAffected, err := res.RowsAffected()
+ if err != nil {
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
fmt.Errorf("determining rows affected for delete server capability: %w", err))
+ return
+ }
+ if rowsAffected == 0 {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("no
rows deleted for server capability"), nil)
+ return
+ }
+
+ api.WriteResp(w, r, "Successfully deleted server capability "+name)
Review Comment:
This seems like it should be a success-level alert instead of a `response`
##########
traffic_ops/traffic_ops_golang/servercapability/servercapability.go:
##########
@@ -151,6 +153,202 @@ func (v *TOServerCapability) Update(h http.Header)
(error, error, int) {
return nil, nil, http.StatusOK
}
+func GetServerCapability(w http.ResponseWriter, r *http.Request) {
+ var sc tc.ServerCapabilityV4
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ tx := inf.Tx
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ // Query Parameters to Database Query column mappings
+ queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{
+ "name": {Column: "sc.name", Checker: nil},
+ }
+ if _, ok := inf.Params["orderby"]; !ok {
+ inf.Params["orderby"] = "name"
+ }
+ where, orderBy, pagination, queryValues, errs :=
dbhelpers.BuildWhereAndOrderByAndPagination(inf.Params, queryParamsToQueryCols)
+ if len(errs) > 0 {
+ api.HandleErr(w, r, tx.Tx, http.StatusBadRequest,
util.JoinErrs(errs), nil)
+ return
+ }
+
+ selectQuery := "SELECT name, description, last_updated FROM
server_capability sc"
+ query := selectQuery + where + orderBy + pagination
+ rows, err := tx.NamedQuery(query, queryValues)
+ if err != nil {
+ api.HandleErr(w, r, tx.Tx, http.StatusInternalServerError, nil,
fmt.Errorf("server capability read: error getting server capability(ies): %w",
err))
+ return
+ }
+ defer log.Close(rows, "unable to close DB connection")
+
+ scList := []tc.ServerCapabilityV4{}
+ for rows.Next() {
+ if err = rows.Scan(&sc.Name, &sc.Description, &sc.LastUpdated);
err != nil {
+ api.HandleErr(w, r, tx.Tx,
http.StatusInternalServerError, nil, fmt.Errorf("error getting server
capability(ies): %w", err))
+ return
+ }
+ scList = append(scList, sc)
+ }
+
+ api.WriteResp(w, r, scList)
+ return
+}
+
+func UpdateServerCapability(w http.ResponseWriter, r *http.Request) {
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+
+ tx := inf.Tx.Tx
+ sc, readValErr := readAndValidateJsonStruct(r)
+ if readValErr != nil {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil)
+ return
+ }
+
+ requestedName := inf.Params["name"]
+ // check if the entity was already updated
+ userErr, sysErr, errCode = api.CheckIfUnModifiedByName(r.Header,
inf.Tx, requestedName, "server_capability")
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, tx, errCode, userErr, sysErr)
+ return
+ }
+
+ //update name and description of a capability
+ query := `UPDATE server_capability sc SET
+ name = $1,
+ description = $2
+ WHERE sc.name = $3
+ RETURNING sc.name, sc.description, sc.last_updated`
+
+ err := tx.QueryRow(query, sc.Name, sc.Description,
requestedName).Scan(&sc.Name, &sc.Description, &sc.LastUpdated)
+ if err != nil && err == sql.ErrNoRows {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, err, nil)
+ return
+ }
+ alerts := tc.CreateAlerts(tc.SuccessLevel, "server capability was
updated")
+ api.WriteAlertsObj(w, r, http.StatusOK, alerts, sc)
+ return
+}
+
+func CreateServerCapability(w http.ResponseWriter, r *http.Request) {
+ inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
+ if userErr != nil || sysErr != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
+ return
+ }
+ defer inf.Close()
+ tx := inf.Tx.Tx
+
+ sc, readValErr := readAndValidateJsonStruct(r)
+ if readValErr != nil {
+ api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil)
+ return
+ }
+
+ // check if capability already exists
+ var count int
+ err := tx.QueryRow("SELECT count(*) from server_capability where name =
$1", sc.Name).Scan(&count)
+ if err != nil {
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
fmt.Errorf("checking if server capability with name %s exists", sc.Name))
+ return
+ }
+ if count == 1 {
+ api.HandleErr(w, r, tx, http.StatusBadRequest,
fmt.Errorf("server_capability name '%s' already exists.", sc.Name), nil)
+ return
+ }
+
+ // create server capability
+ query := `INSERT INTO server_capability (name, description) VALUES ($1,
$2) RETURNING last_updated`
+ err = tx.QueryRow(query, sc.Name, sc.Description).Scan(&sc.LastUpdated)
+ if err != nil && err == sql.ErrNoRows {
+ api.HandleErr(w, r, tx, http.StatusInternalServerError, nil,
err)
+ return
+ }
Review Comment:
same as above RE: ignoring database errors/using `api.ParseDBError`
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
