mhoppa commented on a change in pull request #4339: cachegroupparameters rewrite
URL: https://github.com/apache/trafficcontrol/pull/4339#discussion_r373662577
##########
File path: traffic_ops/traffic_ops_golang/cachegroupparameter/parameters.go
##########
@@ -180,3 +187,137 @@ func (cgparam *TOCacheGroupParameter) Delete() (error,
error, int) {
return api.GenericDelete(cgparam)
}
+
+// ReadAllCacheGroupParameters reads all cachegroup parameter associations.
+func ReadAllCacheGroupParameters(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()
+ output, err := GetAllCacheGroupParameters(inf.Tx, inf.Params)
+ if err != nil {
+ api.WriteRespAlertObj(w, r, tc.ErrorLevel, "querying
cachegroupparameters with error: "+err.Error(), output)
+ return
+ }
+ api.WriteResp(w, r, output)
+}
+
+// GetAllCacheGroupParameters gets all cachegroup associations from the
database and returns as slice.
+func GetAllCacheGroupParameters(tx *sqlx.Tx, parameters map[string]string)
(tc.CacheGroupParametersList, error) {
+ if _, ok := parameters["orderby"]; !ok {
+ parameters["orderby"] = "cachegroup"
+ }
+
+ // Query Parameters to Database Query column mappings
+ // see the fields mapped in the SQL query
+ queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{
+ "cachegroup": dbhelpers.WhereColumnInfo{"cgp.cachegroup",
api.IsInt},
+ "parameter": dbhelpers.WhereColumnInfo{"cgp.parameter",
api.IsInt},
+ }
+
+ where, orderBy, pagination, queryValues, errs :=
dbhelpers.BuildWhereAndOrderByAndPagination(parameters, queryParamsToQueryCols)
+ if len(errs) > 0 {
+ return tc.CacheGroupParametersList{}, util.JoinErrs(errs)
+ }
+
+ log.Errorf("MATT JACKSON queryparams = %s", queryValues)
+ log.Errorf("MATT JACKSON parameters = %s", parameters)
+ log.Errorf("MATT JACKSON query = %s",
selectAllQuery()+where+orderBy+pagination)
+ query := selectAllQuery() + where + orderBy + pagination
+ rows, err := tx.NamedQuery(query, queryValues)
+ if err != nil {
+ return tc.CacheGroupParametersList{}, errors.New("querying
cachegroupParameters: " + err.Error())
+ }
+ defer rows.Close()
+
+ paramsList := tc.CacheGroupParametersList{}
+ params := []tc.CacheGroupParametersResponseNullable{}
+ for rows.Next() {
+ var p tc.CacheGroupParametersNullable
+ if err = rows.Scan(&p.CacheGroup, &p.Parameter, &p.LastUpdated,
&p.CacheGroupName); err != nil {
+ return tc.CacheGroupParametersList{},
errors.New("scanning cachegroupParameters: " + err.Error())
+ }
+ params = append(params, tc.FormatForResponse(p))
+ }
+ paramsList.CacheGroupParameters = params
+ return paramsList, nil
+}
+
+// AddCacheGroupParameters performs a Create for cachegroup parameter
associations.
+// AddCacheGroupParameters accepts data as a single association or an array of
multiple.
+func AddCacheGroupParameters(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()
+
+ data, err := ioutil.ReadAll(r.Body)
+ if err != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest,
errors.New("reading request body: "+err.Error()), nil)
+ return
+ }
+
+ buf := ioutil.NopCloser(bytes.NewReader(data))
+
+ var paramsInt interface{}
+
+ decoder := json.NewDecoder(buf)
+ err = decoder.Decode(¶msInt)
+ if err != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest,
errors.New("parsing json: "+err.Error()), nil)
+ return
+ }
+
+ var params []tc.CacheGroupParametersNullable
+ _, ok := paramsInt.([]interface{})
+ var parseErr error = nil
+ if !ok {
+ var singleParam tc.CacheGroupParametersNullable
+ parseErr = json.Unmarshal(data, &singleParam)
+ if singleParam.CacheGroup == nil || singleParam.Parameter ==
nil {
+ api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest,
errors.New("invalid cachegroup parameter."), nil)
+ return
+ }
+ params = append(params, singleParam)
+ } else {
+ parseErr = json.Unmarshal(data, ¶ms)
+ }
+ if parseErr != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest,
errors.New("parsing cachegroup parameter: "+parseErr.Error()), nil)
+ return
+ }
+
+ values := []string{}
+ for _, param := range params {
+ values = append(values, "("+strconv.Itoa(*param.CacheGroup)+",
"+strconv.Itoa(*param.Parameter)+")")
+ }
+
+ insQuery := strings.Join(values, ", ")
+ _, err = inf.Tx.Tx.Query(insertQuery() + insQuery)
+
+ if err != nil {
+ userErr, sysErr, code := api.ParseDBError(err)
+ api.HandleErr(w, r, inf.Tx.Tx, code, userErr, sysErr)
+ return
+ }
+
+ api.WriteRespAlertObj(w, r, tc.SuccessLevel, "Cachegroup parameter
associations were created.", params)
+}
+
+func selectAllQuery() string {
+ return `SELECT cgp.cachegroup, cgp.parameter, cgp.last_updated, cg.name
+ FROM cachegroup_parameter AS cgp
+ JOIN cachegroup AS cg ON cg.id = cachegroup`
+ //return `SELECT cachegroup, parameter, last_updated FROM
cachegroup_parameter`
Review comment:
remove comment
----------------------------------------------------------------
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.
For queries about this service, please contact Infrastructure at:
[email protected]
With regards,
Apache Git Services
