3. Issues

go tool anetos make:model Issue --migration

// Issue is a bug or a task. `go tool anetos gen` writes its typed columns
// (IssueCols) and relations (IssueRels) to models_gen.go.
type Issue struct {
	db.Model        // id, created_at, updated_at
	Title    string `db:"title"`
	Body     string `db:"body"`
	Status   string `db:"status"` // "open" or "closed"
	AuthorID int64  `db:"author_id"`

	Author *User `rel:"belongs_to"` // by AuthorID
}

func(s *migrate.Schema) error {
	return s.Create("issues", func(t *migrate.Table) {
		t.ID()
		t.String("title", 200)
		t.Text("body")
		t.String("status", 10).Default("open")
		t.ForeignID("author_id").References("users")
		t.Timestamps()
	})
},

go run . migrate
go tool anetos gen

go tool anetos make:handler Issues

import (
	"net/http"

	"anetos.dev/anetos/auth"
	"anetos.dev/anetos/db"
	"anetos.dev/anetos/web"

	"tracker/app/models"
	"tracker/views"
)

// IssueList is the input of GET /issues: the page number, from ?page=.
type IssueList struct {
	Page int `query:"page"`
}

// Index lists the issues, newest first, 20 a page.
func (Issues) Index(c *web.Ctx, in IssueList) (web.Responder, error) {
	page, err := db.Query[models.Issue](c).
		With(models.IssueRels.Author).
		OrderBy(models.IssueCols.ID.Desc()).
		Paginate(in.Page, 20)
	if err != nil {
		return nil, err
	}
	return web.View(views.IssuesPage(page)), nil
}

// IssueInput is the issue form. Its validate tags are checked before the
// handler runs: an invalid form goes back with its errors.
type IssueInput struct {
	Title string `json:"title" validate:"required|max:200"`
	Body  string `json:"body" validate:"max:10000"`
}

// New shows the form for a new issue.
func (Issues) New(c *web.Ctx) error {
	return c.Render(http.StatusOK, views.IssueForm(models.Issue{}))
}

// Create opens an issue by the signed-in user.
func (Issues) Create(c *web.Ctx, in IssueInput) (web.Responder, error) {
	u, err := auth.Current[*models.User](c)
	if err != nil {
		return nil, err
	}
	issue := models.Issue{Title: in.Title, Body: in.Body, Status: "open", AuthorID: u.ID}
	if err := db.Create(c, &issue); err != nil {
		return nil, err
	}
	c.Session().Flash("status", "Issue opened.")
	return web.RedirectRoute("issues.index"), nil
}

// IssueID reads {id} from the path.
type IssueID struct {
	ID int64 `path:"id"`
}

// UpdateIssue is the input of PUT /issues/{id}: the path and the form.
type UpdateIssue struct {
	IssueID
	IssueInput
}

// own returns the issue if the signed-in user wrote it: others get a
// 403, and an issue that doesn't exist is a 404 (db.ErrNotFound).
func own(c *web.Ctx, id int64) (models.Issue, error) {
	issue, err := db.Find[models.Issue](c, id)
	if err != nil {
		return issue, err
	}
	u, err := auth.Current[*models.User](c)
	if err != nil {
		return issue, err
	}
	if issue.AuthorID != u.ID {
		return issue, web.Error(http.StatusForbidden, "Only the issue's author can change it.")
	}
	return issue, nil
}

// Edit shows the form to edit an issue.
func (Issues) Edit(c *web.Ctx, in IssueID) (web.Responder, error) {
	issue, err := own(c, in.ID)
	if err != nil {
		return nil, err
	}
	return web.View(views.IssueForm(issue)), nil
}

// Update saves the issue.
func (Issues) Update(c *web.Ctx, in UpdateIssue) (web.Responder, error) {
	issue, err := own(c, in.ID)
	if err != nil {
		return nil, err
	}
	issue.Title, issue.Body = in.Title, in.Body
	if err := db.Update(c, &issue); err != nil {
		return nil, err
	}
	c.Session().Flash("status", "Issue saved.")
	return web.RedirectRoute("issues.index"), nil
}

import (
	"fmt"

	"anetos.dev/anetos/db"
	"anetos.dev/anetos/view"
	"anetos.dev/anetos/web"

	"tracker/app/models"
)

// IssuesPage lists a page of issues, with links to the pages around it.
templ IssuesPage(page db.Page[models.Issue]) {
	@Layout("Issues") {
		<div class="page-header">
			<h1>Issues</h1>
			<a class="button" href={ web.URL(ctx, "issues.new") }>New issue</a>
		</div>
		if page.Total == 0 {
			<p class="empty">No issues yet.</p>
		} else {
			<div class="table-wrap">
				<table>
					<tbody>
						for _, issue := range page.Data {
							<tr>
								<td><span class={ "badge", templ.KV("success", issue.Status == "open") }>{ issue.Status }</span></td>
								<td><a href={ templ.URL(fmt.Sprintf("/issues/%d", issue.ID)) }>{ issue.Title }</a></td>
								<td class="muted">#{ issue.ID } by { issue.Author.Name }</td>
							</tr>
						}
					</tbody>
				</table>
			</div>
		}
		<nav class="pagination">
			if page.HasPrev() {
				<a href={ web.PageURL(ctx, page.CurrentPage-1) }>Newer</a>
			}
			if page.HasMore() {
				<a href={ web.PageURL(ctx, page.CurrentPage+1) }>Older</a>
			}
		</nav>
	}
}

// IssueForm opens an issue, or edits one when issue.ID is set. After a
// failed post, view.Old refills the fields and view.Errors has the
// messages.
templ IssueForm(issue models.Issue) {
	@Layout("Issue") {
		<div class="narrow">
			if issue.ID == 0 {
				<h1>New issue</h1>
				<form method="post" action={ web.URL(ctx, "issues.store") } class="card">
					@issueFields(issue)
				</form>
			} else {
				<h1>Edit #{ issue.ID }</h1>
				<form method="post" action={ web.URL(ctx, "issues.update", issue.ID) } class="card">
					@view.MethodField("PUT")
					@issueFields(issue)
				</form>
			}
		</div>
	}
}

templ issueFields(issue models.Issue) {
	@view.CSRFField(ctx)
	<div class="field">
		<label for="title">Title</label>
		<input id="title" name="title" value={ view.Old(ctx, "title", issue.Title) }/>
		@fieldError("title")
	</div>
	<div class="field">
		<label for="body">Description</label>
		<textarea id="body" name="body" rows="6">{ view.Old(ctx, "body", issue.Body) }</textarea>
		@fieldError("body")
	</div>
	<button type="submit">Save</button>
}

// fieldError shows the message of a field that failed validation.
templ fieldError(field string) {
	if msg := view.Errors(ctx).Get(field); msg != "" {
		<p class="error">{ msg }</p>
	}
}

// The tracker's pages, for signed-in users.
var issues handlers.Issues
members.Get("/issues", web.H(issues.Index)).Name("issues.index")
members.Get("/issues/new", issues.New).Name("issues.new")
members.Post("/issues", web.H(issues.Create)).Name("issues.store")
members.Get("/issues/{id}/edit", web.H(issues.Edit)).Name("issues.edit")
members.Put("/issues/{id}", web.H(issues.Update)).Name("issues.update")

@navLink("issues.index", "Issues")

import (
	"fmt"

	"anetos.dev/anetos/db/factory"

	"tracker/app/models"
)

// Users are users named User 1, User 2…, with addresses to match.
var Users = factory.New(func(n int) models.User {
	return models.User{Name: fmt.Sprintf("User %d", n), Email: fmt.Sprintf("user%[email protected]", n)}
})

import (
	"net/url"
	"testing"

	"anetos.dev/anetos/anetostest"

	"tracker/app/models"
	"tracker/database/factories"
)

func TestIssues(t *testing.T) {
	app := anetostest.New(t, setup)
	ada := anetostest.Create(app, factories.Users)
	anetostest.ActingAs(app, &ada) // signed in for the requests that follow

	app.Get("/issues/new").AssertOK()
	// Invalid: back to the form, with the errors.
	app.PostForm("/issues", url.Values{"title": {""}}).
		AssertRedirect("/issues/new").
		AssertValidationErrors("title")
	// Valid: to the list, which shows it.
	app.PostForm("/issues", url.Values{"title": {"Login fails"}, "body": {"Since Tuesday."}}).
		AssertRedirect("/issues").
		Follow().
		AssertSee("Issue opened.", "Login fails", "by "+ada.Name)
	anetostest.AssertDatabaseHas[models.Issue](app, models.IssueCols.Title.Eq("Login fails"), models.IssueCols.AuthorID.Eq(ada.ID))

	// Only its author edits it.
	app.PutForm("/issues/1", url.Values{"title": {"Login fails on Safari"}}).AssertRedirect("/issues")
	grace := anetostest.Create(app, factories.Users)
	anetostest.ActingAs(app, &grace)
	app.Get("/issues/1/edit").AssertForbidden()
	app.Get("/issues/2/edit").AssertNotFound()

	// Guests go to the login page.
	app.PostForm("/logout", nil)
	app.Get("/issues").AssertRedirect("/login")
}

go test ./...