mirror of https://github.com/miguelmota/cointop
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
432 lines
9.9 KiB
Go
432 lines
9.9 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/bradfitz/slice"
|
|
humanize "github.com/dustin/go-humanize"
|
|
"github.com/gizak/termui"
|
|
"github.com/jroimartin/gocui"
|
|
"github.com/miguelmota/cointop/apis"
|
|
apitypes "github.com/miguelmota/cointop/apis/types"
|
|
"github.com/miguelmota/cointop/color"
|
|
"github.com/miguelmota/cointop/pad"
|
|
"github.com/miguelmota/cointop/table"
|
|
)
|
|
|
|
var (
|
|
oneMinute int64 = 60
|
|
oneHour = oneMinute * 60
|
|
oneDay = oneHour * 24
|
|
oneWeek = oneDay * 7
|
|
oneMonth = oneDay * 30
|
|
oneYear = oneDay * 365
|
|
)
|
|
|
|
// Cointop cointop
|
|
type Cointop struct {
|
|
g *gocui.Gui
|
|
chartview *gocui.View
|
|
chartpoints [][]termui.Cell
|
|
headersview *gocui.View
|
|
tableview *gocui.View
|
|
table *table.Table
|
|
sortdesc bool
|
|
currentsort string
|
|
api apis.Interface
|
|
coins []*apitypes.Coin
|
|
}
|
|
|
|
func (ct *Cointop) layout(g *gocui.Gui) error {
|
|
maxX, maxY := g.Size()
|
|
|
|
chartHeight := 10
|
|
if v, err := g.SetView("chart", 0, 0, maxX, chartHeight); err != nil {
|
|
if err != gocui.ErrUnknownView {
|
|
return err
|
|
}
|
|
ct.chartview = v
|
|
ct.chartview.Frame = false
|
|
ct.updateChart()
|
|
}
|
|
|
|
if v, err := g.SetView("header", 0, chartHeight, maxX, maxY); err != nil {
|
|
if err != gocui.ErrUnknownView {
|
|
return err
|
|
}
|
|
t := table.New().SetWidth(maxX)
|
|
headers := []string{
|
|
pad.Right("[r]ank", 13, " "),
|
|
pad.Right("[n]ame", 13, " "),
|
|
pad.Right("[s]ymbol", 8, " "),
|
|
pad.Left("[p]rice", 10, " "),
|
|
pad.Left("[m]arket cap", 17, " "),
|
|
pad.Left("24H [v]olume", 15, " "),
|
|
pad.Left("[1]H%", 9, " "),
|
|
pad.Left("[2]4H%", 9, " "),
|
|
pad.Left("[7]D%", 9, " "),
|
|
pad.Left("[t]otal supply", 20, " "),
|
|
pad.Left("[a]vailable supply", 19, " "),
|
|
pad.Left("[l]ast updated", 17, " "),
|
|
}
|
|
for _, h := range headers {
|
|
t.AddCol(h)
|
|
}
|
|
|
|
t.Format().Fprint(v)
|
|
ct.headersview = v
|
|
ct.headersview.Highlight = true
|
|
ct.headersview.SelBgColor = gocui.ColorGreen
|
|
ct.headersview.SelFgColor = gocui.ColorBlack
|
|
ct.headersview.Frame = false
|
|
}
|
|
|
|
if v, err := g.SetView("table", 0, chartHeight+1, maxX, maxY); err != nil {
|
|
if err != gocui.ErrUnknownView {
|
|
return err
|
|
}
|
|
ct.tableview = v
|
|
ct.tableview.Highlight = true
|
|
ct.tableview.SelBgColor = gocui.ColorCyan
|
|
ct.tableview.SelFgColor = gocui.ColorBlack
|
|
ct.tableview.Frame = false
|
|
ct.updateTable()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (ct *Cointop) sort(sortby string, desc bool) func(g *gocui.Gui, v *gocui.View) error {
|
|
return func(g *gocui.Gui, v *gocui.View) error {
|
|
if ct.currentsort == sortby {
|
|
ct.sortdesc = !ct.sortdesc
|
|
} else {
|
|
ct.currentsort = sortby
|
|
ct.sortdesc = desc
|
|
}
|
|
slice.Sort(ct.coins[:], func(i, j int) bool {
|
|
if ct.sortdesc {
|
|
i, j = j, i
|
|
}
|
|
a := ct.coins[i]
|
|
b := ct.coins[j]
|
|
switch sortby {
|
|
case "rank":
|
|
return a.Rank < b.Rank
|
|
case "name":
|
|
return a.Name < b.Name
|
|
case "symbol":
|
|
return a.Symbol < b.Symbol
|
|
case "price":
|
|
return a.PriceUSD < b.PriceUSD
|
|
case "marketcap":
|
|
return a.MarketCapUSD < b.MarketCapUSD
|
|
case "24hvolume":
|
|
return a.USD24HVolume < b.USD24HVolume
|
|
case "1hchange":
|
|
return a.PercentChange1H < b.PercentChange1H
|
|
case "24hchange":
|
|
return a.PercentChange24H < b.PercentChange24H
|
|
case "7dchange":
|
|
return a.PercentChange7D < b.PercentChange7D
|
|
case "totalsupply":
|
|
return a.TotalSupply < b.TotalSupply
|
|
case "availablesupply":
|
|
return a.AvailableSupply < b.AvailableSupply
|
|
case "lastupdated":
|
|
return a.LastUpdated < b.LastUpdated
|
|
default:
|
|
return a.Rank < b.Rank
|
|
}
|
|
})
|
|
g.Update(func(g *gocui.Gui) error {
|
|
ct.tableview.Clear()
|
|
ct.updateTable()
|
|
return nil
|
|
})
|
|
/*
|
|
g.Update(func(g *gocui.Gui) error {
|
|
ct.chartview.Clear()
|
|
maxX, _ := g.Size()
|
|
_, cy := ct.chartview.Cursor()
|
|
coin := "ethereum"
|
|
ct.chartPoints(maxX, coin)
|
|
ct.updateChart()
|
|
fmt.Fprint(ct.chartview, cy)
|
|
return nil
|
|
})
|
|
*/
|
|
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func (ct *Cointop) cursorDown(g *gocui.Gui, v *gocui.View) error {
|
|
if ct.tableview == nil {
|
|
return nil
|
|
}
|
|
_, y := ct.tableview.Origin()
|
|
cx, cy := ct.tableview.Cursor()
|
|
numRows := len(ct.coins) - 1
|
|
//fmt.Fprint(v, cy)
|
|
if (cy + y + 1) > numRows {
|
|
return nil
|
|
}
|
|
if err := ct.tableview.SetCursor(cx, cy+1); err != nil {
|
|
ox, oy := ct.tableview.Origin()
|
|
if err := ct.tableview.SetOrigin(ox, oy+1); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ct *Cointop) cursorUp(g *gocui.Gui, v *gocui.View) error {
|
|
if ct.tableview == nil {
|
|
return nil
|
|
}
|
|
ox, oy := ct.tableview.Origin()
|
|
cx, cy := ct.tableview.Cursor()
|
|
//fmt.Fprint(v, oy)
|
|
if err := ct.tableview.SetCursor(cx, cy-1); err != nil && oy > 0 {
|
|
if err := ct.tableview.SetOrigin(ox, oy-1); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ct *Cointop) pageDown(g *gocui.Gui, v *gocui.View) error {
|
|
if ct.tableview == nil {
|
|
return nil
|
|
}
|
|
_, y := ct.tableview.Origin()
|
|
cx, cy := ct.tableview.Cursor()
|
|
numRows := len(ct.coins) - 1
|
|
_, sy := ct.tableview.Size()
|
|
rows := sy
|
|
if (cy + y + rows) > numRows {
|
|
// go to last row
|
|
ct.tableview.SetCursor(cx, numRows)
|
|
ox, _ := ct.tableview.Origin()
|
|
ct.tableview.SetOrigin(ox, numRows)
|
|
return nil
|
|
}
|
|
if err := ct.tableview.SetCursor(cx, cy+rows); err != nil {
|
|
ox, oy := ct.tableview.Origin()
|
|
if err := ct.tableview.SetOrigin(ox, oy+rows); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ct *Cointop) pageUp(g *gocui.Gui, v *gocui.View) error {
|
|
if ct.tableview == nil {
|
|
return nil
|
|
}
|
|
ox, oy := ct.tableview.Origin()
|
|
cx, cy := ct.tableview.Cursor()
|
|
_, sy := ct.tableview.Size()
|
|
rows := sy
|
|
//fmt.Fprint(v, oy)
|
|
if err := ct.tableview.SetCursor(cx, cy-rows); err != nil && oy > 0 {
|
|
if err := ct.tableview.SetOrigin(ox, oy-rows); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ct *Cointop) fetchData() ([]*apitypes.Coin, error) {
|
|
limit := 100
|
|
result := []*apitypes.Coin{}
|
|
coins, err := ct.api.GetAllCoinData(int(limit))
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
|
|
for i := range coins {
|
|
coin := coins[i]
|
|
result = append(result, &coin)
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (ct *Cointop) chartPoints(maxX int, coin string) error {
|
|
chart := termui.NewLineChart()
|
|
chart.Height = 10
|
|
chart.AxesColor = termui.ColorWhite
|
|
chart.LineColor = termui.ColorCyan
|
|
chart.Border = false
|
|
|
|
now := time.Now()
|
|
secs := now.Unix()
|
|
start := secs - oneDay
|
|
end := secs
|
|
|
|
_ = coin
|
|
//graphData, err := cmc.GetCoinGraphData(coin, start, end)
|
|
graphData, err := ct.api.GetGlobalMarketGraphData(start, end)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
return nil
|
|
}
|
|
|
|
var data []float64
|
|
/*
|
|
for i := range graphData.PriceUSD {
|
|
data = append(data, graphData.PriceUSD[i][1])
|
|
}
|
|
*/
|
|
for i := range graphData.MarketCapByAvailableSupply {
|
|
data = append(data, graphData.MarketCapByAvailableSupply[i][1])
|
|
}
|
|
chart.Data = data
|
|
termui.Body = termui.NewGrid()
|
|
termui.Body.Width = maxX
|
|
termui.Body.AddRows(
|
|
termui.NewRow(
|
|
termui.NewCol(12, 0, chart),
|
|
),
|
|
)
|
|
|
|
var points [][]termui.Cell
|
|
// calculate layout
|
|
termui.Body.Align()
|
|
w := termui.Body.Width
|
|
h := 10
|
|
row := termui.Body.Rows[0]
|
|
b := row.Buffer()
|
|
for i := 0; i < h; i = i + 1 {
|
|
var rowpoints []termui.Cell
|
|
for j := 0; j < w; j = j + 1 {
|
|
p := b.At(j, i)
|
|
rowpoints = append(rowpoints, p)
|
|
}
|
|
points = append(points, rowpoints)
|
|
}
|
|
|
|
ct.chartpoints = points
|
|
return nil
|
|
}
|
|
|
|
func (ct *Cointop) updateChart() error {
|
|
maxX, _ := ct.g.Size()
|
|
if len(ct.chartpoints) == 0 {
|
|
ct.chartPoints(maxX, "bitcoin")
|
|
}
|
|
|
|
for i := range ct.chartpoints {
|
|
var s string
|
|
for j := range ct.chartpoints[i] {
|
|
p := ct.chartpoints[i][j]
|
|
s = fmt.Sprintf("%s%c", s, p.Ch)
|
|
}
|
|
fmt.Fprintln(ct.chartview, s)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ct *Cointop) updateTable() error {
|
|
maxX, _ := ct.g.Size()
|
|
ct.table = table.New().SetWidth(maxX)
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.AddCol("")
|
|
ct.table.HideColumHeaders = true
|
|
var err error
|
|
if len(ct.coins) == 0 {
|
|
ct.coins, err = ct.fetchData()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, coin := range ct.coins {
|
|
unix, _ := strconv.ParseInt(coin.LastUpdated, 10, 64)
|
|
lastUpdated := time.Unix(unix, 0).Format("15:04:05 Jan 02")
|
|
colorprice := color.Cyan
|
|
color1h := color.White
|
|
color24h := color.White
|
|
color7d := color.White
|
|
if coin.PercentChange1H > 0 {
|
|
color1h = color.Green
|
|
}
|
|
if coin.PercentChange1H < 0 {
|
|
color1h = color.Red
|
|
}
|
|
if coin.PercentChange24H > 0 {
|
|
color24h = color.Green
|
|
}
|
|
if coin.PercentChange24H < 0 {
|
|
color24h = color.Red
|
|
}
|
|
if coin.PercentChange7D > 0 {
|
|
color7d = color.Green
|
|
}
|
|
if coin.PercentChange7D < 0 {
|
|
color7d = color.Red
|
|
}
|
|
ct.table.AddRow(
|
|
pad.Left(fmt.Sprint(coin.Rank), 4, " "),
|
|
pad.Right(coin.Name, 22, " "),
|
|
pad.Right(coin.Symbol, 6, " "),
|
|
colorprice(pad.Left(humanize.Commaf(coin.PriceUSD), 12, " ")),
|
|
pad.Left(humanize.Commaf(coin.MarketCapUSD), 17, " "),
|
|
pad.Left(humanize.Commaf(coin.USD24HVolume), 15, " "),
|
|
color1h(pad.Left(fmt.Sprintf("%.2f%%", coin.PercentChange1H), 9, " ")),
|
|
color24h(pad.Left(fmt.Sprintf("%.2f%%", coin.PercentChange24H), 9, " ")),
|
|
color7d(pad.Left(fmt.Sprintf("%.2f%%", coin.PercentChange7D), 9, " ")),
|
|
pad.Left(humanize.Commaf(coin.TotalSupply), 20, " "),
|
|
pad.Left(humanize.Commaf(coin.AvailableSupply), 18, " "),
|
|
pad.Left(fmt.Sprintf("%s", lastUpdated), 18, " "),
|
|
// add %percent of cap
|
|
)
|
|
}
|
|
|
|
ct.table.Format().Fprint(ct.tableview)
|
|
return nil
|
|
}
|
|
|
|
func (ct *Cointop) quit(g *gocui.Gui, v *gocui.View) error {
|
|
return gocui.ErrQuit
|
|
}
|
|
|
|
func main() {
|
|
g, err := gocui.NewGui(gocui.Output256)
|
|
if err != nil {
|
|
log.Fatalf("new gocui: %v", err)
|
|
}
|
|
defer g.Close()
|
|
g.Cursor = true
|
|
g.Mouse = true
|
|
g.Highlight = true
|
|
|
|
ct := Cointop{
|
|
g: g,
|
|
api: apis.NewCMC(),
|
|
}
|
|
g.SetManagerFunc(ct.layout)
|
|
|
|
if err := ct.keybindings(g); err != nil {
|
|
log.Fatalf("keybindings: %v", err)
|
|
}
|
|
|
|
if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
|
|
log.Fatalf("main loop: %v", err)
|
|
}
|
|
}
|