prime8dev

wakatime.go (5723B)

---

 package external
 
 import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"os"
 	"strings"
 	"time"
 
 	"github.com/patrickmn/go-cache"
 )
 
 type WakaTime struct {
 	httpClient *http.Client
 	baseURL    string
 	apiKey     string
 	cache      *cache.Cache
 }
 
 func NewWakaTime(c *cache.Cache) *WakaTime {
 	return &WakaTime{
 		httpClient: &http.Client{
 			Timeout: 10 * time.Second,
 		},
 		baseURL: "https://wakatime.com/api/v1",
 		apiKey:  strings.TrimSpace(os.Getenv("WAKATIME_API_KEY")),
 		cache:   c,
 	}
 }
 
 type WakaTimeStats struct {
 	AllTime AllTimeStats
 	Weekly  WeeklyStats
 }
 
 func (s *WakaTime) FetchStats() (*WakaTimeStats, error) {
 	if s.apiKey == "" {
 		return nil, nil
 	}
 
 	cacheKey := "wakatime:stats"
 
 	if val, found := s.cache.Get(cacheKey); found {
 		return val.(*WakaTimeStats), nil
 	}
 
 	allTime, err := s.fetchAllTimeStats()
 	if err != nil {
 		return nil, err
 	}
 
 	weekly, err := s.fetchWeeklyStats()
 	if err != nil {
 		return nil, err
 	}
 
 	stats := &WakaTimeStats{
 		AllTime: *allTime,
 		Weekly:  *weekly,
 	}
 
 	s.cache.Set(cacheKey, stats, 5*time.Minute)
 	return stats, nil
 }
 
 type allTimeResponse struct {
 	Data struct {
 		TotalSeconds float64 `json:"total_seconds"`
 	} `json:"data"`
 }
 
 type languagesResponse struct {
 	Data struct {
 		DailyAverageIncludingOtherLanguage float64 `json:"daily_average_including_other_language"`
 	} `json:"data"`
 }
 
 type AllTimeStats struct {
 	TotalText        string
 	DailyAverageText string
 }
 
 func (s *WakaTime) fetchAllTimeStats() (*AllTimeStats, error) {
 	cacheKey := "wakatime:alltime"
 
 	if val, found := s.cache.Get(cacheKey); found {
 		return val.(*AllTimeStats), nil
 	}
 
 	statsCh := make(chan *allTimeResponse, 1)
 	langCh := make(chan *languagesResponse, 1)
 	errCh := make(chan error, 2)
 
 	go func() {
 		resp, err := s.makeRequest("/users/current/all_time_since_today")
 		if err != nil {
 			errCh <- err
 			return
 		}
 		var data allTimeResponse
 		if err := json.Unmarshal(resp, &data); err != nil {
 			errCh <- err
 			return
 		}
 		statsCh <- &data
 	}()
 
 	go func() {
 		resp, err := s.makeRequest("/users/current/stats/last_year")
 		if err != nil {
 			errCh <- err
 			return
 		}
 		var data languagesResponse
 		if err := json.Unmarshal(resp, &data); err != nil {
 			errCh <- err
 			return
 		}
 		langCh <- &data
 	}()
 
 	var stats *allTimeResponse
 	var langStats *languagesResponse
 
 	for range 2 {
 		select {
 		case s := <-statsCh:
 			stats = s
 		case l := <-langCh:
 			langStats = l
 		case err := <-errCh:
 			return nil, err
 		}
 	}
 
 	totalSeconds := 0.0
 	if stats != nil {
 		totalSeconds = stats.Data.TotalSeconds
 	}
 	totalHours := int(totalSeconds / 3600)
 	totalText := fmt.Sprintf("%d+ hrs coded", totalHours)
 
 	dailyAvgText := "0 mins"
 	if langStats != nil && langStats.Data.DailyAverageIncludingOtherLanguage > 0 {
 		dailyAvgText = formatDuration(langStats.Data.DailyAverageIncludingOtherLanguage)
 	}
 
 	result := &AllTimeStats{
 		TotalText:        totalText,
 		DailyAverageText: dailyAvgText,
 	}
 
 	s.cache.Set(cacheKey, result, 5*time.Minute)
 	return result, nil
 }
 
 func formatDuration(seconds float64) string {
 	hours := int(seconds / 3600)
 	minutes := int((seconds - float64(hours)*3600) / 60)
 
 	if hours > 0 {
 		return fmt.Sprintf("%d hrs %d mins", hours, minutes)
 	}
 	return fmt.Sprintf("%d mins", minutes)
 }
 
 type summariesResponse struct {
 	Data []struct {
 		Range struct {
 			Date string `json:"date"`
 		} `json:"range"`
 		GrandTotal struct {
 			TotalSeconds float64 `json:"total_seconds"`
 		} `json:"grand_total"`
 	} `json:"data"`
 }
 
 type WeeklyStats struct {
 	TotalText string
 	Days      []DailyEntry
 }
 
 type DailyEntry struct {
 	DayText         string
 	DateText        string
 	TimeText        string
 	BarWidthPercent string
 }
 
 func (s *WakaTime) fetchWeeklyStats() (*WeeklyStats, error) {
 	cacheKey := "wakatime:weekly"
 
 	if val, found := s.cache.Get(cacheKey); found {
 		return val.(*WeeklyStats), nil
 	}
 
 	end := time.Now()
 	start := end.AddDate(0, 0, -6)
 
 	url := fmt.Sprintf("/users/current/summaries?start=%s&end=%s",
 		start.Format("2006-01-02"),
 		end.Format("2006-01-02"))
 
 	resp, err := s.makeRequest(url)
 	if err != nil {
 		return nil, err
 	}
 
 	var data summariesResponse
 	if err := json.Unmarshal(resp, &data); err != nil {
 		return nil, err
 	}
 
 	days := make([]DailyEntry, 0, len(data.Data))
 	var totalSeconds float64
 	var maxMinutes = 1
 	minutesPerDay := make([]int, len(data.Data))
 
 	for i, day := range data.Data {
 		date, _ := time.Parse("2006-01-02", day.Range.Date)
 
 		dayText := date.Weekday().String()[:3]
 		dateText := fmt.Sprintf("%s %d", date.Month().String()[:3], date.Day())
 
 		seconds := day.GrandTotal.TotalSeconds
 		totalSeconds += seconds
 
 		minutes := int(seconds / 60)
 		minutesPerDay[i] = minutes
 		if minutes > maxMinutes {
 			maxMinutes = minutes
 		}
 
 		timeText := formatDuration(seconds)
 
 		days = append(days, DailyEntry{
 			DayText:  dayText,
 			DateText: dateText,
 			TimeText: timeText,
 		})
 	}
 
 	for i := range days {
 		days[i].BarWidthPercent = fmt.Sprintf("%d%%", (minutesPerDay[i]*100)/maxMinutes)
 	}
 
 	result := &WeeklyStats{
 		TotalText: formatDuration(totalSeconds),
 		Days:      days,
 	}
 
 	s.cache.Set(cacheKey, result, 5*time.Minute)
 	return result, nil
 }
 
 func (s *WakaTime) makeRequest(path string) ([]byte, error) {
 	url := s.baseURL + path
 
 	req, err := http.NewRequest("GET", url, nil)
 	if err != nil {
 		return nil, err
 	}
 
 	auth := base64.StdEncoding.EncodeToString([]byte(s.apiKey))
 	req.Header.Set("Authorization", fmt.Sprintf("Basic %s", auth))
 
 	resp, err := s.httpClient.Do(req)
 	if err != nil {
 		return nil, err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
 		return nil, fmt.Errorf("wakatime API returned %d", resp.StatusCode)
 	}
 
 	return io.ReadAll(resp.Body)
 }