path: root/tjp.go

package main

import (
	"database/sql"
	"flag"
	"fmt"
	"log"
	"os"
	"time"

	_ "github.com/lib/pq"
)

// Database connection details
const (
	host   = "postgres.banded-neon.ts.net"
	user   = "postgresql"
	dbname = "journal"
)

var db *sql.DB

func init() {
	var err error
	// Connection string
	psqlInfo := fmt.Sprintf("host=%s user=%s dbname=%s sslmode=disable", host, user, dbname)
	db, err = sql.Open("postgres", psqlInfo)
	if err != nil {
		log.Fatal(err)
	}

	if err = db.Ping(); err != nil {
		log.Fatal(err)
	}
}

func addMODContact(firstName, lastName string) {
	var contactId int
	query := `INSERT INTO contacts (first_name, last_name, contact_type) VALUES ($1, $2, 3) RETURNING id`
	err := db.QueryRow(query, firstName, lastName).Scan(&contactId)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("MOD contact added with ID: %d\n", contactId)
}

func addSleepEntry(entry string) {
	_, err := db.Exec("INSERT INTO journal_entries (entry, type) VALUES ($1, 4)", entry)
	if err != nil {
		log.Fatal(err)
	}
}

func addPersonalEntry(entry string) {
	_, err := db.Exec("INSERT INTO journal_entries (entry, type) VALUES ($1, 2)", entry)
	if err != nil {
		log.Fatal(err)
	}
}

func addMODEntry(entry string) {
	_, err := db.Exec("INSERT INTO journal_entries (entry, type) VALUES ($1, 1)", entry)
	if err != nil {
		log.Fatal(err)
	}
}

func listPersonalEntries(orientation string) {
	var rows *sql.Rows

	var id sql.NullInt64
	var dateAdded sql.NullTime
	var entry sql.NullString
	var comment sql.NullString

	rows, err := db.Query("SELECT id, date_added, entry, comment FROM journal_entries WHERE type = 2 ORDER BY date_added ASC, id ASC")
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	fmt.Println("Personal Entries:")

	var previousDateAdded sql.NullTime   // Track the previous date only
	previousDateAdded.Time = time.Time{} // Initialize to zero value

	// Scan for each row
	for rows.Next() {
		if err := rows.Scan(&id, &dateAdded, &entry, &comment); err != nil {
			log.Fatal(err)
		}

		// Check if previousDateAdded is valid to avoid printing dash before first entry
		if previousDateAdded.Valid && dateAdded.Valid && !sameDay(previousDateAdded.Time, dateAdded.Time) {
			fmt.Println("----") // Print a dashed line between different day entries
		}

		if orientation == "vertical" {
			formatVertically(id, dateAdded, entry, comment)
		} else if orientation == "horizontal" {
			formatHorizontally(dateAdded, entry, comment)
		}

		previousDateAdded = dateAdded // Update previousDateAdded to current date
	}
}

// Function to determine if two times are on the same day
func sameDay(t1, t2 time.Time) bool {
	return t1.Year() == t2.Year() && t1.YearDay() == t2.YearDay()
}

func formatVertically(id sql.NullInt64, dateAdded sql.NullTime, entry sql.NullString, comment sql.NullString) {
	fmt.Printf("ID: %s\n", formatInt64(id))
	fmt.Printf("Date Added: %s\n", formatTime(dateAdded))
	fmt.Printf("Entry: %s\n", formatString(entry))
	fmt.Printf("Comment: %s\n", formatString(comment))
}

func formatHorizontally(dateAdded sql.NullTime, entry sql.NullString, comment sql.NullString) {
	fmt.Printf("%s | %s | %s\n", formatShortTime(dateAdded), formatString(entry), formatString(comment))
}

func formatShortTime(t sql.NullTime) string {
	if t.Valid {
		return t.Time.Format("2006-01-02T15:04")
	}
	return "NULL"
}

// Helper functions to handle sql.Null* types
func formatInt64(v sql.NullInt64) string {
	if v.Valid {
		return fmt.Sprintf("%d", v.Int64)
	}
	return "NULL"
}

func formatTime(v sql.NullTime) string {
	if v.Valid {
		return v.Time.Format(time.RFC3339)
	}
	return "NULL"
}

func formatString(v sql.NullString) string {
	if v.Valid {
		return v.String
	}
	return "NULL"
}

func main() {

	// Define flags
	addMODFlag := flag.Bool("addMOD", false, "Add a MOD contact with first name and last name")
	firstName := flag.String("firstName", "", "First name of the contact")
	lastName := flag.String("lastName", "", "Last name of the contact")

	orientationFlag := flag.String("orientation", "horizontal", "Orientation of the journal entries (vertical or horizontal)")

	addSleepEntryFlag := flag.Bool("addSleepEntry", false, "Add a sleep entry")
	sleepEntry := flag.String("sleepEntry", "", "Content of the sleep entry")

	addPersonalEntryFlag := flag.Bool("p", false, "Add a personal entry")
	entry := flag.String("entry", "", "Content of the journal entry")

	addMODEntryFlag := flag.Bool("addMODEntry", false, "Add a MOD entry")

	listPersonalEntriesFlag := flag.Bool("l", false, "List all personal entries")

	// Parse flags
	flag.Parse()

	// Call functions based on flags
	if *addMODFlag {
		if *firstName == "" || *lastName == "" {
			log.Fatal("Both firstName and lastName must be provided for adding a MOD contact")
		}
		addMODContact(*firstName, *lastName)
	} else if *addSleepEntryFlag {
		if *sleepEntry == "" {
			log.Fatal("Sleep entry content must be provided")
		}
		addSleepEntry(*sleepEntry)
	} else if *addPersonalEntryFlag {
		if *entry == "" {
			log.Fatal("Personal entry content must be provided - use the -entry flag")
		}
		addPersonalEntry(*entry)
	} else if *addMODEntryFlag {
		if *entry == "" {
			log.Fatal("MOD entry content must be provided - use the -entry flag")
		}
		addMODEntry(*entry)
	} else if *listPersonalEntriesFlag {
		listPersonalEntries(*orientationFlag)
	} else {
		flag.Usage() // Print usage if no valid flags are provided
		os.Exit(1)
	}
}