ketotrack/main.go

243 lines
5.6 KiB
Go
Raw Normal View History

2024-05-12 02:06:45 +00:00
package main
import (
"bufio"
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
"strconv"
"strings"
"time"
)
var recordsFilename string
2024-05-12 02:06:45 +00:00
func init() {
// Get user's homeDir directory
homeDir, err := os.UserHomeDir()
if err != nil {
fmt.Println("Error fetching user's home directory:", err)
os.Exit(1)
}
// Define the path to the application data directory
ketotrackDir := filepath.Join(homeDir, ".ketotrack")
// Create the directory if it does not exist
err = os.MkdirAll(ketotrackDir, 0770)
if err != nil {
fmt.Println("Error creating .ketotrack directory:", err)
os.Exit(1)
}
// Set data file path for readings
recordsFilename = filepath.Join(ketotrackDir, "records.json")
2024-05-12 02:06:45 +00:00
}
2024-05-12 18:13:24 +00:00
// Record holds a pointer to a Reading or Note.
type Record struct {
Reading *Reading `json:"reading,omitempty"`
Note *Note `json:"note,omitempty"`
}
// Note holds a text note along with the time the note was taken.
type Note struct {
Time time.Time `json:"time"`
Text string `json:"text"`
}
2024-05-12 18:45:04 +00:00
// NewNote returns a new Note
func NewNote(text string) Note {
return Note{
Time: time.Now(),
Text: text,
}
}
2024-05-12 02:06:45 +00:00
// Reading holds the glucose and ketone level measurements along with the time the measurements were taken.
type Reading struct {
Time time.Time `json:"time"`
Glucose float64 `json:"glucose"`
Ketone float64 `json:"ketone"`
2024-05-12 18:09:50 +00:00
GKI float64 `json:"GKI"`
2024-05-12 02:06:45 +00:00
}
// NewReading creates and returns a new Reading instance with the provided glucose and ketone levels, and records
// the current time. The glucose value should be provided in mg/dL, while the ketone level should be in mmol/L.
func NewReading(glucose, ketone float64) Reading {
2024-05-12 18:09:50 +00:00
var gki float64
if ketone == 0 {
gki = 0
} else {
gki = (glucose / 18) / ketone
}
2024-05-12 02:06:45 +00:00
return Reading{
Time: time.Now(),
Glucose: glucose,
Ketone: ketone,
2024-05-12 18:09:50 +00:00
GKI: gki,
2024-05-12 02:06:45 +00:00
}
}
2024-05-12 18:22:04 +00:00
// AppContext is the application data store that holds Records
type AppContext struct {
Records []Record
}
// LoadRecords will load records from file
func (ctx *AppContext) LoadRecords(filename string) error {
data, err := os.ReadFile(filename)
if err != nil {
return err
}
return json.Unmarshal(data, &ctx.Records)
}
// SaveRecords will save records to a file
func (ctx *AppContext) SaveRecords(filename string) error {
jsonData, err := json.Marshal(ctx.Records)
if err != nil {
return err
2024-05-12 02:06:45 +00:00
}
2024-05-12 18:22:04 +00:00
return os.WriteFile(filename, jsonData, 0660)
}
// AddReading will add a Reading to the AppContext
func (ctx *AppContext) AddReading(reading Reading) {
ctx.Records = append(ctx.Records, Record{Reading: &reading})
}
// AddNote will a add a Note to the AppContext
func (ctx *AppContext) AddNote(note Note) {
ctx.Records = append(ctx.Records, Record{Note: &note})
}
2024-05-12 02:06:45 +00:00
func main() {
2024-05-12 18:58:23 +00:00
// TODO: Write option handlers (handleNewNote, handleNewReading)
var appCtx AppContext
2024-05-12 02:06:45 +00:00
2024-05-12 18:58:23 +00:00
if err := appCtx.LoadRecords(recordsFilename); err != nil {
fmt.Printf("Error loading records from file: %s\n", err)
2024-05-12 02:06:45 +00:00
}
2024-05-12 18:58:23 +00:00
for {
choice, err := getUserInput("1. Enter new reading\n2. Enter new note\n3. Exit\nYour choice")
if err != nil {
2024-05-12 18:58:23 +00:00
fmt.Printf("Error reading choice: %s\n", err)
continue
}
2024-05-12 18:58:23 +00:00
if choice == "3" {
fmt.Println("Exiting...")
break
}
switch choice {
case "1":
// Get a new Reading from the user
reading, err := getReading()
if err != nil {
fmt.Printf("Error getting reading: %s\n", err)
} else {
appCtx.AddReading(reading)
}
case "2":
// Get a new Note from the user
2024-05-12 19:09:32 +00:00
note, err := getNote()
2024-05-12 18:58:23 +00:00
if err != nil {
fmt.Printf("Error getting note: %s\n", err)
} else {
appCtx.AddNote(note)
}
default:
fmt.Printf("Invalid choice, please try again.\n\n")
}
2024-05-12 02:06:45 +00:00
}
// Save Records before exiting
2024-05-12 18:58:23 +00:00
if err := appCtx.SaveRecords(recordsFilename); err != nil {
2024-05-12 18:45:04 +00:00
fmt.Printf("Error saving records to file: %s\n", err)
}
2024-05-12 02:06:45 +00:00
}
2024-05-12 19:09:32 +00:00
func getNote() (Note, error) {
text, err := getUserInput("Enter note text")
if err != nil {
return Note{}, err
}
return NewNote(text), nil
}
2024-05-12 02:06:45 +00:00
func getReading() (Reading, error) {
// Get glucose reading
glucose, err := getUserFloat("Enter glucose reading (mg/dL)")
if err != nil {
return Reading{}, fmt.Errorf("error getting glucose reading: %w", err)
}
// Validate glucose reading
if glucose <= 0 {
return Reading{}, errors.New("glucose reading cannot be less than or equal to 0")
}
// Get ketone reading
ketone, err := getUserFloat("Enter ketone reading (mmol/L)")
if err != nil {
return Reading{}, fmt.Errorf("error getting ketone reading: %w", err)
}
// Validate ketone reading
if ketone < 0 {
fmt.Println("")
return Reading{}, errors.New("ketone reading cannot be less than 0")
}
2024-05-12 19:03:10 +00:00
reading := NewReading(glucose, ketone)
// Display GKI and level of ketosis
fmt.Printf("\nYour GKI is: %0.2f\n", reading.GKI)
switch {
case reading.GKI <= 1:
fmt.Println("You're in the highest level of ketosis.")
case reading.GKI < 3:
fmt.Println("You're in a high therapeutic level of ketosis.")
case reading.GKI < 6:
fmt.Println("You're in a moderate level of ketosis.")
case reading.GKI <= 9:
fmt.Println("You're in a low level of ketosis.")
default:
fmt.Println("You are not in ketosis.")
}
return reading, nil
2024-05-12 02:06:45 +00:00
}
func getUserInput(prompt string) (string, error) {
fmt.Printf("%s: ", prompt)
reader := bufio.NewReader(os.Stdin)
input, err := reader.ReadString('\n')
if err != nil {
return "", err
}
return strings.TrimSpace(input), nil
}
func getUserFloat(prompt string) (float64, error) {
// Get input as a string
s, err := getUserInput(prompt)
if err != nil {
return 0, err
}
// Convert string to float
f, err := strconv.ParseFloat(s, 64)
if err != nil {
return 0, err
}
return f, nil
}