peert/protastim - Change H4X3MEXPAMD7EFT4SH5QR4SVCH5WBBALEKOKRNGT4GNNC22LCXOQC

Discard old views

Created by peert on April 15, 2025

H4X3MEXPAMD7EFT4SH5QR4SVCH5WBBALEKOKRNGT4GNNC22LCXOQC

Dependencies

In channels

main

Change contents

File deletion: task_view.go

BF:BFD[8.1] → [9.0:36]

BF:BFD[9.36] → [9.37:37]

B:BD[9.37] → [9.38:1211]

∅:D[3.44] → [9.1251:1792]

B:BD[9.1251] → [9.1251:1792]

B:BD[9.1211] → [3.0:44]

package main
import (
	"context"
	"fmt"
	db "github.com/Asfolny/protastim/internal/database"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/bubbles/spinner"
)
type taskModel struct {
	id         int64
	config     *config
	data       *db.Task
	modal      tea.Model
	err        error
	loading    bool
	editing    bool
	spinner    spinner.Model
}
func newTask(config *config, id int64) taskModel {
	m := taskModel{
		id:      id,
		config: config,
		loading: true,
		spinner: config.newSpinner(),
	}
	return m
}
func (m taskModel) fetchTask() tea.Msg {
	row, err := m.config.queries.GetTask(context.Background(), m.id)
	if err != nil {
		return errMsg{err}
	}
	return row
}
func (m taskModel) Init() tea.Cmd {
	return tea.Batch(m.fetchTask, m.spinner.Tick)
}
func (m taskModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case db.Task:
		m.data = &msg
		m.loading = false
		return m, nil
	case errMsg:
		m.err = msg
		m.loading = false
		return m, tea.Quit
	case spinner.TickMsg:
		var cmd tea.Cmd
		m.spinner, cmd = m.spinner.Update(msg)
		return m, cmd
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+n":
			m.editing = true
			return m, m.modal.Init()
		}
	}
	if m.editing {
		var cmd tea.Cmd
		m.modal, cmd = m.modal.Update(msg)
		return m, cmd
	}
	return m, nil
}
func (m taskModel) View() string {
	if m.loading {
		return fmt.Sprintf("\n%s Loading\n\n", m.spinner.View())
	}
	if m.err != nil {
		return fmt.Sprintf("\nFailed fetching task: %v\n\n", m.err)
	}
	if m.editing {
		return m.modal.View()
	}
	return fmt.Sprintf(
		"Name: %s\nDescription:\n%s\nStatus: %s\n",
		m.data.Name,
		m.data.Description.String,
		m.data.Status,
	)
}
			m.modal = newTaskEdit(m.config, nil, "")

File deletion: project_view.go

BF:BFD[8.1] → [10.0:39]

BF:BFD[10.39] → [10.40:40]

B:BD[10.40] → [10.41:82]

∅:D[5.22] → [10.82:136]

B:BD[10.82] → [10.82:136]

∅:D[5.154] → [10.136:178]

B:BD[10.136] → [10.136:178]

∅:D[5.291] → [10.222:252]

B:BD[10.222] → [10.222:252]

∅:D[5.559] → [10.414:494]

B:BD[10.414] → [10.414:494]

∅:D[5.763] → [10.576:580]

B:BD[10.576] → [10.576:580]

B:BD[10.580] → [5.764:1256]

∅:D[5.1256] → [10.580:640]

B:BD[10.580] → [10.580:640]

∅:D[5.1515] → [10.709:751]

B:BD[10.709] → [10.709:751]

∅:D[5.1701] → [10.763:805]

B:BD[10.763] → [10.763:805]

∅:D[5.1766] → [10.855:951]

B:BD[10.855] → [10.855:951]

B:BD[10.951] → [5.1767:1852]

∅:D[5.1852] → [10.951:985]

B:BD[10.951] → [10.951:985]

∅:D[5.1930] → [10.1005:1050]

B:BD[10.1005] → [10.1005:1050]

∅:D[5.1983] → [10.1070:1233]

B:BD[10.1070] → [10.1070:1233]

B:BD[10.1233] → [5.1984:2322]

∅:D[5.2322] → [10.1233:1250]

B:BD[10.1233] → [10.1233:1250]

∅:D[3.580] → [10.1426:1434]

B:BD[10.1426] → [10.1426:1434]

∅:D[5.2475] → [10.1521:1525]

B:BD[10.1521] → [10.1521:1525]

∅:D[5.2491] → [10.1540:1581]

B:BD[10.1540] → [10.1540:1581]

∅:D[5.2515] → [10.1597:1679]

B:BD[10.1597] → [10.1597:1679]

∅:D[5.2590] → [10.1744:1748]

B:BD[10.1744] → [10.1744:1748]

∅:D[5.3291] → [10.1788:1791]

B:BD[10.1788] → [10.1788:1791]

B:BD[10.1791] → [5.3292:3389]

∅:D[5.3389] → [10.1791:1792]

B:BD[10.1791] → [10.1791:1792]

∅:D[5.3702] → [10.1923:1925]

B:BD[10.1923] → [10.1923:1925]

B:BD[10.1792] → [5.3390:3702]

B:BD[10.1748] → [5.2591:3291]

B:BD[10.1679] → [5.2516:2590]

B:BD[10.1581] → [5.2492:2515]

B:BD[10.1525] → [5.2476:2491]

B:BD[10.1434] → [5.2323:2475]

B:BD[10.1250] → [3.368:580]

B:BD[10.1050] → [5.1931:1983]

B:BD[10.985] → [5.1853:1930]

B:BD[10.805] → [5.1702:1766]

B:BD[10.751] → [5.1516:1701]

B:BD[10.640] → [5.1257:1515]

B:BD[10.494] → [5.560:763]

B:BD[10.252] → [5.292:559]

B:BD[10.178] → [5.155:291]

B:BD[10.136] → [5.23:154]

B:BD[10.82] → [5.0:22]

package main
import (
	"context"
	"fmt"
	db "github.com/Asfolny/protastim/internal/database"
	tea "github.com/charmbracelet/bubbletea"
)
type projectModel struct {
}
func newProject(config *config, id int64) projectModel {
	m := projectModel{
	}
	t := table.New(
		table.WithColumns([]table.Column{
			{Title: "ID", Width: 4},
			{Title: "Name"},
			{Title: "Status", Width: 8},
		}),
		table.WithFocused(true),
	)
	ts := table.DefaultStyles()
	ts.Header = ts.Header.
		BorderStyle(lipgloss.NormalBorder()).
		BorderForeground(lipgloss.Color("240")).
		BorderBottom(true).
		Bold(false)
	ts.Selected = ts.Selected.
		Foreground(lipgloss.Color("229")).
		Background(lipgloss.Color("57")).
		Bold(false)
	t.SetStyles(ts)
	m.taskList = t
	return m
}
func (m projectModel) fetchProject() tea.Msg {
	if err != nil {
		return errMsg{err}
	}
}
func (m projectModel) Init() tea.Cmd {
}
func (m projectModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case rows:
		m.loadingTasks = false
		m.taskList.SetRows(msg.data)
		return m, nil
	case db.Project:
		m.data = &msg
		return m, nil
	case errMsg:
		m.err = msg
		return m, tea.Quit
	case spinner.TickMsg:
		var cmd tea.Cmd
		m.spinner, cmd = m.spinner.Update(msg)
		return m, cmd
	case tea.KeyMsg:
		switch msg.String() {
		case "tab":
			switch m.focus {
			case focusDesc:
				m.focus = focusTasks
				m.taskList.Focus()
			case focusTasks:
				m.focus = focusDesc
				m.taskList.Blur()
			}
		case "enter":
			if m.focus == focusTasks {
				id, _ := strconv.ParseInt(m.taskList.SelectedRow()[0], 10, 64)
				return m, changeView(newTask(m.config, id))
			}
		case "ctrl+n":
		}
	}
	}
}
func (m projectModel) View() string {
		return fmt.Sprintf("\n%s Loading\n\n", m.spinner.View())
	}
	if m.err != nil {
	}
	}
	m.taskList.SetColumns(cols)
	m.taskList.SetHeight(desc.Height)
	m.taskList.SetWidth(desc.Width)
}
	descOut := lg.NewStyle().BorderStyle(lipgloss.NormalBorder()).Render(desc.View())
	table := lg.NewStyle().BorderStyle(lipgloss.NormalBorder()).Render(m.taskList.View())
	sb.WriteString(title)
	sb.WriteString(status)
	sb.WriteString(lipgloss.JoinHorizontal(lipgloss.Bottom, descOut, table))
	return sb.String()
	var sb strings.Builder
	lg := m.config.lg
	titleStyle := lg.NewStyle().
		AlignHorizontal(lipgloss.Center).
		Width(m.config.getInnerWidth()).
		MarginTop(2).
		MarginBottom(1).
		Bold(true)
	title := titleStyle.Render(m.data.Name + "\n")
	status := m.config.styles.Base.Render(fmt.Sprintf("Status: %s\n", m.data.Status))
	// TODO more task/desc layouts
	desc := m.descVw
	desc.SetContent(m.data.Description.String)
	desc.Width = (m.config.getInnerWidth() / 2) - 4
	desc.Height = m.config.getInnerHeight() - lipgloss.Height(title) - lipgloss.Height(status)
	cols := m.taskList.Columns()
	for i, col := range cols {
		if col.Title == "Name" {
			col.Width = desc.Width - 4 - 8
			cols[i] = col
		}
		return fmt.Sprintf("\nFailed fetching project or tasks: %v\n\n", m.err)
	if m.loadingProject {
	return m, cmd
	var cmd tea.Cmd
	switch m.focus {
	case focusDesc:
		m.descVw, cmd = m.descVw.Update(msg)
	case focusTasks:
		m.taskList, cmd = m.taskList.Update(msg)
			return m, changeView(newProjectEdit(m.config, nil))
		case "ctrl+e":
			return m, changeView(newProjectEdit(m.config, m.data))
		case "ctrl+t":
			return m, changeView(newTaskEdit(m.config, nil, m.data.Name))
		m.loadingProject = false
		m.loadingTasks = false
		m.loadingProject = false
		m.descVw.SetContent(m.data.Description.String)
	return tea.Batch(m.fetchProject, m.fetchTasks, m.spinner.Tick)
	tableRows := make([]table.Row, len(tasks), len(tasks))
	for i, e := range tasks {
		tableRows[i] = table.Row{strconv.FormatInt(e.ID, 10), e.Name, e.Status}
	}
	return rows{tableRows}
	project, err := m.config.queries.GetProject(context.Background(), m.id)
	if err != nil {
		return errMsg{err}
	}
	return project
}
func (m projectModel) fetchTasks() tea.Msg {
	tasks, err := m.config.queries.ListTasksByProject(context.Background(), m.id)
		id:             id,
		config:         config,
		loadingProject: true,
		loadingTasks:   true,
		spinner:        config.newSpinner(),
		descVw:         viewport.New(0, 0),
		focus:          focusTasks,
	id             int64
	config         *config
	data           *db.Project
	err            error
	loadingProject bool
	loadingTasks   bool
	spinner        spinner.Model
	descVw         viewport.Model
	taskList       table.Model
	focus          projectViewFocusElement
	"github.com/charmbracelet/lipgloss"
)
type projectViewFocusElement int
const (
	focusDesc projectViewFocusElement = iota
	focusTasks
	"github.com/charmbracelet/bubbles/spinner"
	"github.com/charmbracelet/bubbles/table"
	"github.com/charmbracelet/bubbles/viewport"
	"strconv"
	"strings"

File deletion: project_edit.go

BF:BFD[8.1] → [11.0:39]

BF:BFD[11.39] → [11.40:40]

B:BD[11.40] → [11.41:1050]

∅:D[7.21] → [11.1072:1599]

B:BD[11.1072] → [11.1072:1599]

B:BD[11.1618] → [11.1618:2077]

∅:D[2.27] → [11.2100:2203]

B:BD[11.2100] → [11.2100:2203]

B:BD[11.2314] → [11.2314:2425]

∅:D[2.47] → [11.2440:2489]

B:BD[11.2440] → [11.2440:2489]

B:BD[11.2621] → [11.2621:4235]

B:BD[11.2425] → [2.28:47]

B:BD[11.2077] → [2.0:27]

B:BD[11.1050] → [7.0:21]

package main
import (
	"context"
	"database/sql"
	"fmt"
	"strings"
	db "github.com/Asfolny/protastim/internal/database"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/huh"
	"github.com/charmbracelet/lipgloss"
)
type projectEditModel struct {
	config *config
	form   *huh.Form
	width  int
	create bool
}
func newProjectEdit(config *config, project *db.Project) tea.Model {
	m := projectEditModel{config: config, create: project == nil}
	confirmDefault := true
	var name string
	var desc string
	var status string
	if project != nil {
		name = project.Name
		desc = project.Description.String
		status = project.Status
	}
	m.form = huh.NewForm(
		huh.NewGroup(
			huh.NewInput().
				Key("name").
				Title("Name").
				Prompt("> ").
				Validate(huh.ValidateNotEmpty()).
				Value(&name),
			huh.NewText().
				Key("description").
				Title("Description").
				Value(&desc),
			huh.NewSelect[string]().
				Key("status").
				Options(huh.NewOptions("N", "P", "C", "H", "D")...).
				Inline(true).
				Value(&status),
			// TODO make a select between "create and open" and "only create"
			huh.NewConfirm().
				Validate(func(v bool) error { // Should SHOULD close
					if !v {
						return fmt.Errorf("Welp, finish up then")
					}
					return nil
				}).
				Affirmative("done").
				Negative("cancel").
				Inline(true).
				Value(&confirmDefault),
		),
	).
		WithWidth(45).
		WithShowHelp(false).
		WithShowErrors(false)
	return m
}
func (m projectEditModel) Init() tea.Cmd {
	return m.form.Init()
}
func (m projectEditModel) createProjectCmd() func() tea.Msg {
	m.config.mu.Lock()
	defer m.config.mu.Unlock()
	desc := sql.NullString{String: m.form.GetString("description")}
	if desc.String != "" {
		desc.Valid = true
	}
	dataset := db.CreateProjectParams{
		Name:        m.form.GetString("name"),
		Description: desc,
		Status:      m.form.GetString("status"),
	}
	return func() tea.Msg {
		m.config.queries.CreateProject(context.Background(), dataset)
	}
}
func (m projectEditModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.WindowSizeMsg:
		m.width = min(msg.Width, maxWidth) - m.config.styles.Base.GetHorizontalFrameSize()
		return m, changeView(newProjectList(m.config))
	}
	var cmds []tea.Cmd
	// Process the form
	form, cmd := m.form.Update(msg)
	if f, ok := form.(*huh.Form); ok {
		m.form = f
		cmds = append(cmds, cmd)
	}
	if m.form.State == huh.StateCompleted {
		// TODO handle abort
		// TODO handle updating an existing
		cmds = append(cmds, m.createProjectCmd())
	}
	return m, tea.Batch(cmds...)
}
func (m projectEditModel) View() string {
	var status string
	s := m.config.styles
	v := strings.TrimSuffix(m.form.View(), "\n\n")
	form := m.config.lg.NewStyle().Margin(1, 0).Render(v)
	errors := m.form.Errors()
	header := m.appBoundaryView("Charm Employment Application")
	if len(errors) > 0 {
		header = m.appErrorBoundaryView(m.errorView())
	}
	body := lipgloss.JoinHorizontal(lipgloss.Top, form, status)
	footer := m.appBoundaryView(m.form.Help().ShortHelpView(m.form.KeyBinds()))
	if len(errors) > 0 {
		footer = m.appErrorBoundaryView("")
	}
	return s.Base.Render(header + "\n" + body + "\n\n" + footer)
}
func (m projectEditModel) errorView() string {
	var s string
	for _, err := range m.form.Errors() {
		s += err.Error()
	}
	return s
}
func (m projectEditModel) appBoundaryView(text string) string {
	return lipgloss.PlaceHorizontal(
		m.width,
		lipgloss.Left,
		m.config.styles.HeaderText.Render(text),
		lipgloss.WithWhitespaceChars("/"),
		lipgloss.WithWhitespaceForeground(indigo),
	)
}
func (m projectEditModel) appErrorBoundaryView(text string) string {
	return lipgloss.PlaceHorizontal(
		m.width,
		lipgloss.Left,
		m.config.styles.ErrorHeaderText.Render(text),
		lipgloss.WithWhitespaceChars("/"),
		lipgloss.WithWhitespaceForeground(red),
	)
}
	case editingDone:
		return editingDone(true)
				Title("Status").

File deletion: project_list.go

BF:BFD[8.1] → [12.0:39]

BF:BFD[12.39] → [12.40:40]

B:BD[12.40] → [12.41:590]

∅:D[6.28] → [12.649:681]

B:BD[12.649] → [12.649:681]

∅:D[6.49] → [12.681:1069]

B:BD[12.681] → [12.681:1069]

B:BD[12.1109] → [12.1109:1399]

∅:D[6.124] → [12.1473:1904]

B:BD[12.1473] → [12.1473:1904]

B:BD[12.2001] → [12.2001:2473]

∅:D[6.463] → [12.2473:2474]

B:BD[12.2473] → [12.2473:2474]

∅:D[6.543] → [12.2538:2540]

B:BD[12.2538] → [12.2538:2540]

B:BD[12.2474] → [6.464:543]

B:BD[12.2473] → [6.125:463]

B:BD[12.1399] → [6.50:124]

B:BD[12.681] → [6.29:49]

B:BD[12.590] → [6.0:28]

package main
import (
	"context"
	"fmt"
	"strconv"
	"github.com/charmbracelet/bubbles/spinner"
	"github.com/charmbracelet/bubbles/table"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
)
type projectListModel struct {
	config  *config
	table   table.Model
	err     error
	loading bool
	spinner spinner.Model
}
func newProjectList(config *config) projectListModel {
	m := projectListModel{
		config:  config,
		loading: true,
		spinner: config.newSpinner(),
	}
	t := table.New(
		table.WithColumns([]table.Column{
			{Title: "Status", Width: 8},
		}),
		table.WithFocused(true),
		table.WithHeight(8),
	)
	ts := table.DefaultStyles()
	ts.Header = ts.Header.
		BorderStyle(lipgloss.NormalBorder()).
		BorderForeground(lipgloss.Color("240")).
		BorderBottom(true).
		Bold(false)
	ts.Selected = ts.Selected.
		Foreground(lipgloss.Color("229")).
		Background(lipgloss.Color("57")).
		Bold(false)
	t.SetStyles(ts)
	m.table = t
	return m
}
func (m projectListModel) fetchProjects() tea.Msg {
	m.config.mu.RLock()
	defer m.config.mu.RUnlock()
	row, err := m.config.queries.ListProjects(context.Background())
	if err != nil {
		return errMsg{err}
	}
	tableRows := make([]table.Row, len(row), len(row))
	for i, e := range row {
	}
	return rows{tableRows}
}
func (m projectListModel) Init() tea.Cmd {
	return tea.Batch(m.fetchProjects, m.spinner.Tick)
}
func (m projectListModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	var cmd tea.Cmd
	switch msg := msg.(type) {
	case rows:
		m.table.SetRows(msg.data)
		m.loading = false
		return m, nil
	case errMsg:
		m.err = msg
		m.loading = false
		return m, tea.Quit
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+n":
			return m, changeView(newProjectEdit(m.config, nil))
		case "enter":
			id, _ := strconv.ParseInt(m.table.SelectedRow()[0], 10, 64)
			return m, changeView(newProject(m.config, id))
		}
	}
	m.table, cmd = m.table.Update(msg)
	return m, cmd
}
func (m projectListModel) View() string {
	if m.loading {
		return fmt.Sprintf("\n%s Loading\n\n", m.spinner.View())
	}
	if m.err != nil {
		return fmt.Sprintf("\nFailed fetching project: %v\n\n", m.err)
	}
}
	lg := m.config.lg
	return lg.NewStyle().PaddingTop(1).Render(m.table.View())
	// TODO this specific handling should be done within Update instead
	cols := m.table.Columns()
	for i, col := range cols {
		if col.Title == "Name" {
			col.Width = m.config.getInnerWidth() - 4 - 8 - 2
			cols[i] = col
		}
	}
	m.table.SetColumns(cols)
	m.table.SetHeight(m.config.getInnerHeight())
	m.table.SetWidth(m.config.size.Width)
		tableRows[i] = table.Row{strconv.FormatInt(e.ID, 10), e.Status, e.Name}
			{Title: "Name"},
			{Title: "ID", Width: 2},

File deletion: task_list.go

BF:BFD[8.1] → [9.1793:1829]

BF:BFD[9.1829] → [9.1830:1830]

B:BD[9.1830] → [9.1831:3641]

∅:D[3.101] → [9.3693:4154]

B:BD[9.3693] → [9.3693:4154]

B:BD[9.3641] → [3.45:101]

package main
import (
	"context"
	"fmt"
	"strconv"
	"github.com/charmbracelet/bubbles/spinner"
	"github.com/charmbracelet/bubbles/table"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
)
type taskListModel struct {
	config  *config
	table   table.Model
	err     error
	loading bool
	spinner spinner.Model
}
func newTaskList(config *config) taskListModel {
	m := taskListModel{
		config:  config,
		loading: true,
		spinner: config.newSpinner(),
	}
	t := table.New(
		table.WithColumns([]table.Column{
			{Title: "ID", Width: 4},
			{Title: "Name", Width: 10},
			{Title: "Status", Width: 8},
		}),
		table.WithFocused(true),
		table.WithHeight(8),
	)
	ts := table.DefaultStyles()
	ts.Header = ts.Header.
		BorderStyle(lipgloss.NormalBorder()).
		BorderForeground(lipgloss.Color("240")).
		BorderBottom(true).
		Bold(false)
	ts.Selected = ts.Selected.
		Foreground(lipgloss.Color("229")).
		Background(lipgloss.Color("57")).
		Bold(false)
	t.SetStyles(ts)
	m.table = t
	return m
}
func (m taskListModel) fetchTasks() tea.Msg {
	m.config.mu.RLock()
	defer m.config.mu.RUnlock()
	row, err := m.config.queries.ListTasks(context.Background())
	if err != nil {
		return errMsg{err}
	}
	tableRows := make([]table.Row, len(row), len(row))
	for i, e := range row {
		tableRows[i] = table.Row{strconv.FormatInt(e.ID, 10), e.Name, e.Status}
	}
	return rows{tableRows}
}
func (m taskListModel) Init() tea.Cmd {
	return tea.Batch(m.fetchTasks, m.spinner.Tick)
}
func (m taskListModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	var cmd tea.Cmd
	switch msg := msg.(type) {
	case rows:
		m.table.SetRows(msg.data)
		m.loading = false
		return m, nil
	case errMsg:
		m.err = msg
		m.loading = false
		return m, tea.Quit
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+n":
		case "enter":
			id, _ := strconv.ParseInt(m.table.SelectedRow()[0], 10, 64)
			return m, changeView(newTask(m.config, id))
		}
	}
	m.table, cmd = m.table.Update(msg)
	return m, cmd
}
func (m taskListModel) View() string {
	if m.loading {
		return fmt.Sprintf("\n%s Loading\n\n", m.spinner.View())
	}
	if m.err != nil {
		return fmt.Sprintf("\nFailed fetching project: %v\n\n", m.err)
	}
	return m.config.styles.BaseTable.Render(m.table.View()) + "\n"
}
			return m, changeView(newTaskEdit(m.config, nil, ""))

File deletion: task_edit.go

BF:BFD[8.1] → [9.4155:4191]

BF:BFD[9.4191] → [9.4192:4192]

B:BD[9.4192] → [9.4193:4243]

∅:D[4.10] → [9.4243:4516]

B:BD[9.4243] → [9.4243:4516]

∅:D[3.157] → [9.4516:4519]

B:BD[9.4516] → [9.4516:4519]

∅:D[3.367] → [9.4636:5233]

B:BD[9.4636] → [9.4636:5233]

∅:D[4.546] → [9.5328:5677]

B:BD[9.5328] → [9.5328:5677]

∅:D[4.916] → [9.5677:5680]

B:BD[9.5677] → [9.5677:5680]

∅:D[4.1078] → [9.5680:5720]

B:BD[9.5680] → [9.5680:5720]

∅:D[4.1129] → [9.5742:5963]

B:BD[9.5742] → [9.5742:5963]

∅:D[4.1131] → [9.5963:6101]

B:BD[9.5963] → [9.5963:6101]

∅:D[4.1165] → [9.6101:6428]

B:BD[9.6101] → [9.6101:6428]

∅:D[4.1244] → [9.6428:6448]

B:BD[9.6428] → [9.6428:6448]

∅:D[4.1308] → [9.6494:7044]

B:BD[9.6494] → [9.6494:7044]

∅:D[4.1446] → [9.7105:8093]

B:BD[9.7105] → [9.7105:8093]

B:BD[9.7044] → [4.1309:1446]

B:BD[9.6448] → [4.1245:1308]

B:BD[9.6428] → [4.1166:1244]

B:BD[9.6101] → [4.1132:1165]

B:BD[9.5963] → [4.1130:1131]

B:BD[9.5720] → [4.1079:1129]

B:BD[9.5680] → [4.917:1078]

B:BD[9.5677] → [4.547:916]

B:BD[9.5233] → [4.11:546]

B:BD[9.4519] → [3.158:367]

B:BD[9.4516] → [3.102:157]

B:BD[9.4243] → [4.0:10]

package main
import (
	"context"
	"database/sql"
	"fmt"
	"strings"
	db "github.com/Asfolny/protastim/internal/database"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/huh"
	"github.com/charmbracelet/lipgloss"
)
type taskEditModel struct {
	config *config
	form   *huh.Form
	width  int
	create bool
}
	confirmDefault := true
	var name string
	var desc string
	var status string
	if task != nil {
		name = task.Name
		desc = task.Description.String
		status = task.Status
	}
	m.form = huh.NewForm(
		huh.NewGroup(
			huh.NewInput().
				Key("name").
				Title("Name").
				Prompt("> ").
				Validate(huh.ValidateNotEmpty()).
				Value(&name),
			huh.NewText().
				Key("description").
				Title("Description").
				Value(&desc),
			huh.NewSelect[string]().
				Key("status").
				Options(huh.NewOptions("N", "P", "C", "H", "D")...).
				Title("Status ").
				Inline(true).
				Value(&status),
			huh.NewConfirm().
				Validate(func(v bool) error { // Should SHOULD close
					if !v {
						return fmt.Errorf("Welp, finish up then")
					}
					return nil
				}).
				Affirmative("done").
				Negative("cancel").
				Inline(true).
				Value(&confirmDefault),
		),
	).
		WithWidth(45).
		WithShowHelp(false).
		WithShowErrors(false)
	return m
}
func (m taskEditModel) Init() tea.Cmd {
}
func (m taskEditModel) createTaskCmd() func() tea.Msg {
	m.config.mu.Lock()
	defer m.config.mu.Unlock()
	desc := sql.NullString{String: m.form.GetString("description")}
	if desc.String != "" {
		desc.Valid = true
	}
	dataset := db.CreateTaskParams{
		Name:        m.form.GetString("name"),
		Description: desc,
		Status:      m.form.GetString("status"),
	}
	return func() tea.Msg {
		m.config.queries.CreateTask(context.Background(), dataset)
		return editingDone(true)
	}
}
func (m taskEditModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.WindowSizeMsg:
		m.width = min(msg.Width, maxWidth) - m.config.styles.Base.GetHorizontalFrameSize()
	case editingDone:
	}
	var cmds []tea.Cmd
	// Process the form
	form, cmd := m.form.Update(msg)
	if f, ok := form.(*huh.Form); ok {
		m.form = f
		cmds = append(cmds, cmd)
	}
	if m.form.State == huh.StateCompleted {
		// TODO handle abort
		// TODO handle updating an existing
		cmds = append(cmds, m.createTaskCmd())
	}
	return m, tea.Batch(cmds...)
}
func (m taskEditModel) View() string {
	var status string
	s := m.config.styles
	v := strings.TrimSuffix(m.form.View(), "\n\n")
	form := m.config.lg.NewStyle().Margin(1, 0).Render(v)
	errors := m.form.Errors()
	if len(errors) > 0 {
		header = m.appErrorBoundaryView(m.errorView())
	}
	body := lipgloss.JoinHorizontal(lipgloss.Top, form, status)
	footer := m.appBoundaryView(m.form.Help().ShortHelpView(m.form.KeyBinds()))
	if len(errors) > 0 {
		footer = m.appErrorBoundaryView("")
	}
	return s.Base.Render(header + "\n" + body + "\n\n" + footer)
}
func (m taskEditModel) errorView() string {
	var s string
	for _, err := range m.form.Errors() {
		s += err.Error()
	}
	return s
}
func (m taskEditModel) appBoundaryView(text string) string {
	return lipgloss.PlaceHorizontal(
		m.width,
		lipgloss.Left,
		m.config.styles.HeaderText.Render(text),
		lipgloss.WithWhitespaceChars("/"),
		lipgloss.WithWhitespaceForeground(indigo),
	)
}
func (m taskEditModel) appErrorBoundaryView(text string) string {
	return lipgloss.PlaceHorizontal(
		m.width,
		lipgloss.Left,
		m.config.styles.ErrorHeaderText.Render(text),
		lipgloss.WithWhitespaceChars("/"),
		lipgloss.WithWhitespaceForeground(red),
	)
}
	var header string
	if m.create {
		header = m.appBoundaryView("Create Task")
	} else {
		header = m.appBoundaryView("Update Task")
	}
		return m, changeView(newProject(m.config, m.getProjectId()))
	case []db.Project:
		*m.projects = msg
		*m.loading = false
		return m, nil
		ProjectID:   m.getProjectId(),
	return tea.Batch(m.form.Init(), m.fetchProjects)
func (m taskEditModel) getProjectId() int64 {
	for _, e := range *m.projects {
		if e.Name == m.form.GetString("project") {
			return e.ID
		}
	}
	return 0
}
}
func (m taskEditModel) projectsAsOptions() []string {
	l := make([]string, len(*m.projects) + 1)
	l[0] = "Choose a project"
	for i, e := range *m.projects {
		l[i+1] = e.Name
		i++
	}
	return l
}
func (m taskEditModel) fetchProjects() tea.Msg {
	row, err := m.config.queries.ListProjects(context.Background())
	if err != nil {
		return errMsg{err}
	}
	return row
			huh.NewSelect[string]().
				Key("project").
				Title("Project").
				OptionsFunc(func() []huh.Option[string] {
					if *m.loading {
						empty := make([]string, 2)
						empty[0] = "Loading..."
						empty[1] = m.project
						return huh.NewOptions(empty...)
					}
					return huh.NewOptions(m.projectsAsOptions()...)
				}, m.loading).
				Validate(func(val string) error {
					if (val == "Choose a project") {
						return errors.New("Must choose a project for task")
					}
					return nil
				}).
				Value(&m.project),
func newTaskEdit(config *config, task *db.Task, project string) tea.Model {
	t := true
	var p []db.Project
	m := taskEditModel{config: config, create: task == nil, loading: &t, projects: &p, project: project}
	loading *bool
	projects *[]db.Project
	project string
	"errors"

Deletion in main.go at line 18 [14.32]
B:BD[13.82] → [13.82:83]
B:BD[13.83] → [2.48:70]
```
type editingDone bool
```