coder · Emyrk · Jun 14, 2022 · Jun 7, 2022 · Jun 8, 2022 · Jun 8, 2022
diff --git a/coderd/database/databasefake/databasefake.go b/coderd/database/databasefake/databasefake.go
@@ -327,12 +327,41 @@ func (q *fakeQuerier) GetWorkspacesWithFilter(_ context.Context, arg database.Ge
 		if arg.OwnerID != uuid.Nil && workspace.OwnerID != arg.OwnerID {
 			continue
 		}
+		if arg.OwnerUsername != "" {
+			owner, err := q.GetUserByID(context.Background(), workspace.OwnerID)
+			if err == nil && arg.OwnerUsername != owner.Username {
+				continue
+			}
+		}
+		if arg.TemplateName != "" {
+			templates, err := q.GetTemplatesByName(context.Background(), database.GetTemplatesByNameParams{
+				Name: arg.TemplateName,
+			})
+			// Add to later param
+			if err == nil {
+				for _, t := range templates {
+					arg.TemplateIds = append(arg.TemplateIds, t.ID)
+				}
+			}
+		}
 		if !arg.Deleted && workspace.Deleted {
 			continue
 		}
 		if arg.Name != "" && !strings.Contains(workspace.Name, arg.Name) {
 			continue
 		}
+		if len(arg.TemplateIds) > 0 {
+			match := false
+			for _, id := range arg.TemplateIds {
+				if workspace.TemplateID == id {
+					match = true
+					break
+				}
+			}
+			if !match {
+				continue
+			}
+		}
 		workspaces = append(workspaces, workspace)
 	}
 
@@ -761,6 +790,26 @@ func (q *fakeQuerier) UpdateTemplateMetaByID(_ context.Context, arg database.Upd
 	return sql.ErrNoRows
 }
 
+func (q *fakeQuerier) GetTemplatesByName(_ context.Context, arg database.GetTemplatesByNameParams) ([]database.Template, error) {
+	q.mutex.RLock()
+	defer q.mutex.RUnlock()
+	var templates []database.Template
+	for _, template := range q.templates {
+		if !strings.EqualFold(template.Name, arg.Name) {
+			continue
+		}
+		if template.Deleted != arg.Deleted {
+			continue
+		}
+		templates = append(templates, template)
+	}
+	if len(templates) > 0 {
+		return templates, nil
+	}
+
+	return nil, sql.ErrNoRows
+}
+
 func (q *fakeQuerier) GetTemplateVersionsByTemplateID(_ context.Context, arg database.GetTemplateVersionsByTemplateIDParams) (version []database.TemplateVersion, err error) {
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()

diff --git a/coderd/database/querier.go b/coderd/database/querier.go
diff --git a/coderd/database/queries.sql.go b/coderd/database/queries.sql.go
diff --git a/coderd/database/queries/templates.sql b/coderd/database/queries/templates.sql
@@ -28,6 +28,15 @@ WHERE
 LIMIT
 	1;
 
+-- name: GetTemplatesByName :many
+SELECT
+	*
+FROM
+	templates
+WHERE
+	deleted = @deleted
+	AND LOWER("name") = LOWER(@name);
+
 -- name: GetTemplatesByOrganization :many
 SELECT
 	*

diff --git a/coderd/database/queries/workspaces.sql b/coderd/database/queries/workspaces.sql
@@ -15,7 +15,7 @@ FROM
     workspaces
 WHERE
     -- Optionally include deleted workspaces
-	deleted = @deleted
+	workspaces.deleted = @deleted
 	-- Filter by organization_id
 	AND CASE
 		WHEN @organization_id :: uuid != '00000000-00000000-00000000-00000000' THEN
@@ -24,15 +24,35 @@ WHERE
 	END
 	-- Filter by owner_id
 	AND CASE
-		  WHEN @owner_id :: uuid != '00000000-00000000-00000000-00000000' THEN
-				owner_id = @owner_id
-		  ELSE true
+		WHEN @owner_id :: uuid != '00000000-00000000-00000000-00000000' THEN
+			owner_id = @owner_id
+		ELSE true
+	END
+  	-- Filter by owner_name
+	AND CASE
+		WHEN @owner_username :: text != '' THEN
+			owner_id = (SELECT id FROM users WHERE username = @owner_username)
+		ELSE true
+	END
+	-- Filter by template_name
+	-- There can be more than 1 template with the same name across organizations.
+  	-- Use the organization filter to restrict to 1 org if needed.
+	AND CASE
+		WHEN @template_name :: text != '' THEN
+			template_id = (SELECT id FROM templates WHERE name = @template_name)
+		ELSE true
+	END
+	-- Filter by template_ids
+	AND CASE
+		WHEN array_length(@template_ids :: uuid[], 1) > 0 THEN
+			template_id = ANY(@template_ids)
+		ELSE true
 	END
 	-- Filter by name, matching on substring
 	AND CASE
-		  WHEN @name :: text != '' THEN
-				LOWER(name) LIKE '%' || LOWER(@name) || '%'
-		  ELSE true
+		WHEN @name :: text != '' THEN
+			LOWER(name) LIKE '%' || LOWER(@name) || '%'
+		ELSE true
 	END
 ;
 

diff --git a/coderd/httpapi/queryparams.go b/coderd/httpapi/queryparams.go
@@ -0,0 +1,109 @@
+package httpapi
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/google/uuid"
+
+	"golang.org/x/xerrors"
+)
+
+// QueryParamParser is a helper for parsing all query params and gathering all
+// errors in 1 sweep. This means all invalid fields are returned at once,
+// rather than only returning the first error
+type QueryParamParser struct {
+	errors []Error
+}
+
+func NewQueryParamParser() *QueryParamParser {
+	return &QueryParamParser{
+		errors: []Error{},
+	}
+}
+
+// ValidationErrors is the set of errors to return via the API. If the length
+// of this set is 0, there was no errors.
+func (p QueryParamParser) ValidationErrors() []Error {
+	return p.errors
+}
+
+func (p *QueryParamParser) ParseInteger(r *http.Request, def int, queryParam string) int {
+	v, err := parse(r, strconv.Atoi, def, queryParam)
+	if err != nil {
+		p.errors = append(p.errors, Error{
+			Field:  queryParam,
+			Detail: fmt.Sprintf("Query param %q must be a valid integer (%s)", queryParam, err.Error()),
+		})
+	}
+	return v
+}
+
+func (p *QueryParamParser) ParseUUIDorMe(r *http.Request, def uuid.UUID, me uuid.UUID, queryParam string) uuid.UUID {
+	if r.URL.Query().Get(queryParam) == "me" {
+		return me
+	}
+	return p.ParseUUID(r, def, queryParam)
+}
+
+func (p *QueryParamParser) ParseUUID(r *http.Request, def uuid.UUID, queryParam string) uuid.UUID {
+	v, err := parse(r, uuid.Parse, def, queryParam)
+	if err != nil {
+		p.errors = append(p.errors, Error{
+			Field:  queryParam,
+			Detail: fmt.Sprintf("Query param %q must be a valid uuid", queryParam),
+		})
+	}
+	return v
+}
+
+func (p *QueryParamParser) ParseUUIDArray(r *http.Request, def []uuid.UUID, queryParam string) []uuid.UUID {
+	v, err := parse(r, func(v string) ([]uuid.UUID, error) {
+		var badValues []string
+		strs := strings.Split(v, ",")
+		ids := make([]uuid.UUID, 0, len(strs))
+		for _, s := range strs {
+			id, err := uuid.Parse(strings.TrimSpace(s))
+			if err != nil {
+				badValues = append(badValues, v)
+				continue
+			}
+			ids = append(ids, id)
+		}
+
+		if len(badValues) > 0 {
+			return []uuid.UUID{}, xerrors.Errorf("%s", strings.Join(badValues, ","))
+		}
+		return ids, nil
+	}, def, queryParam)
+	if err != nil {
+		p.errors = append(p.errors, Error{
+			Field:  queryParam,
+			Detail: fmt.Sprintf("Query param %q has invalid uuids: %q", queryParam, err.Error()),
+		})
+	}
+	return v
+}
+
+func (p *QueryParamParser) ParseString(r *http.Request, def string, queryParam string) string {
+	v, err := parse(r, func(v string) (string, error) {
+		return v, nil
+	}, def, queryParam)
+	if err != nil {
+		p.errors = append(p.errors, Error{
+			Field:  queryParam,
+			Detail: fmt.Sprintf("Query param %q must be a valid string", queryParam),
+		})
+	}
+	return v
+}
+
+func parse[T any](r *http.Request, parse func(v string) (T, error), def T, queryParam string) (T, error) {
+	if !r.URL.Query().Has(queryParam) {
+		return def, nil
+	}
+	str := r.URL.Query().Get(queryParam)
+	return parse(str)
+}