mctl/database/commands.go

package database

import (
	"fmt"
	"os"

	"code.jakeyoungdev.com/jake/mctl/model"
	"github.com/jmoiron/sqlx"
	_ "github.com/ncruces/go-sqlite3/driver"
	_ "github.com/ncruces/go-sqlite3/embed"
)

type database struct {
	*sqlx.DB
}

type Database interface {
	Init() error
	Destroy() error
	Close() error
	//command methods
	GetCmd(name string) (string, error)
	GetAllCmds() ([]model.Command, error)
	SaveCmd(name, cmd string) error
	UpdateCmd(name, cmd string) error
	DeleteCmd(name string) error
	//server methods
	GetServer(name string) (model.Server, error)
	GetAllServers() ([]model.Server, error)
	SaveServer(srv model.Server) error
	UpdateServer(name, password string) error
	DeleteServer(name string) error
}

func New() (Database, error) {
	home, err := os.UserHomeDir()
	if err != nil {
		return nil, err
	}
	db, err := sqlx.Open("sqlite3", fmt.Sprintf("file:%s/.mctl", home))
	if err != nil {
		return nil, err
	}

	return &database{
		db,
	}, nil
}

func (d *database) Init() error {
	query := `
		CREATE TABLE IF NOT EXISTS commands(
			name TEXT PRIMARY KEY,
			command TEXT
		)

		CREATE TABLE IF NOT EXISTS servers(
			name TEXT PRIMARY KEY,
			server TEXT,
			password TEXT,
			port NUMBER
		)
	`

	_, err := d.Exec(query)
	return err
}

func (d *database) Destroy() error {
	query := `
		DROP TABLE commands
		DROP TABLE servers
	`

	_, err := d.Exec(query)
	return err
}

func (d *database) Close() error {
	return d.Close()
}

func (d *database) GetCmd(name string) (string, error) {
	query := `
		SELECT
			command
		FROM
			commands
		WHERE
			name = ?
	`

	var cmd string
	err := d.QueryRowx(query, name).Scan(&cmd)
	if err != nil {
		return "", err
	}

	return name, nil
}

func (d *database) GetAllCmds() ([]model.Command, error) {
	query := `
		SELECT
			name,
			command
		FROM
			commands
	`

	rows, err := d.Queryx(query)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var res []model.Command
	for rows.Next() {
		var r model.Command
		err := rows.StructScan(&r)
		if err != nil {
			return nil, err
		}

		res = append(res, r)
	}

	return res, nil
}

func (d *database) SaveCmd(name, cmd string) error {
	query := `
		INSERT INTO commands(name, command)
		VALUES(?, ?)
	`

	_, err := d.Exec(query, name, cmd)
	return err
}

func (d *database) UpdateCmd(name, cmd string) error {
	query := `
		UPDATE 
			commands
		SET
			cmd = ?
		WHERE
			name = ?
	`

	_, err := d.Exec(query, cmd, name)
	return err
}

func (d *database) DeleteCmd(name string) error {
	query := `
		DELETE FROM commands
		WHERE name = ?
	`

	_, err := d.Exec(query, name)
	return err
}

func (d *database) GetServer(name string) (model.Server, error) {
	query := `
		SELECT
			name,
			server,
			password,
			port
		FROM
			servers
		WHERE
			name = ?
	`

	var s model.Server
	err := d.QueryRowx(query, name).StructScan(&s)
	if err != nil {
		return model.Server{}, err
	}
	return s, nil
}

func (d *database) GetAllServers() ([]model.Server, error) {
	query := `
		SELECT
			name,
			server,
			password,
			port
		FROM
			servers
	`

	rows, err := d.Queryx(query)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var res []model.Server
	for rows.Next() {
		var r model.Server
		err := rows.StructScan(&r)
		if err != nil {
			return nil, err
		}

		res = append(res, r)
	}

	return res, nil
}

func (d *database) SaveServer(srv model.Server) error {
	query := `
		INSERT INTO servers(name, server, password, port)
		VALUES(?, ?, ?, ?)
	`

	_, err := d.Exec(query, srv.Name, srv.Server, srv.Password, srv.Port)
	return err
}

// updates server password, if anymore fields need updated the entry should be deleted and recreated
func (d *database) UpdateServer(name, password string) error {
	query := `
		UPDATE servers
		SET
			password = ?
		WHERE
			name = ?
	`

	_, err := d.Exec(query, password, name)
	return err
}

func (d *database) DeleteServer(name string) error {
	query := `
		DELETE FROM servers
		WHERE 
			name = ?
	`

	_, err := d.Exec(query, name)
	return err
}