815 lines
18 KiB
Go
815 lines
18 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type dayContributions map[string]int
|
|
type activityMap map[string]dayContributions
|
|
|
|
type config struct {
|
|
githubAPIKey string
|
|
forgejoAPIKey string
|
|
forgejoUser string
|
|
forgejoURL string
|
|
gitlabAPIKey string
|
|
gitlabUser string
|
|
gitlabURL string
|
|
}
|
|
|
|
type app struct {
|
|
config config
|
|
client *http.Client
|
|
now time.Time
|
|
oneYearAgo time.Time
|
|
formattedOneYearAgo string
|
|
}
|
|
|
|
func main() {
|
|
outputPath, err := parseArgs(os.Args[1:])
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(2)
|
|
}
|
|
|
|
if err := loadDotEnv(); err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
now := time.Now()
|
|
oneYearAgo := now.AddDate(-1, 0, 0)
|
|
a := app{
|
|
config: loadConfig(),
|
|
client: &http.Client{Timeout: 30 * time.Second},
|
|
now: now,
|
|
oneYearAgo: oneYearAgo,
|
|
formattedOneYearAgo: formatGitHubTime(oneYearAgo),
|
|
}
|
|
|
|
activity, err := a.makeActivityMap()
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if err := os.MkdirAll(filepath.Dir(outputPath), 0o755); err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
data, err := json.MarshalIndent(activity, "", " ")
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
data = append(data, '\n')
|
|
|
|
if err := os.WriteFile(outputPath, data, 0o644); err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
fmt.Printf("Wrote %d days of activity to %s\n", len(activity), outputPath)
|
|
}
|
|
|
|
func parseArgs(args []string) (string, error) {
|
|
fs := flag.NewFlagSet("get_history", flag.ContinueOnError)
|
|
fs.SetOutput(os.Stdout)
|
|
fs.Usage = func() {
|
|
fmt.Fprintln(fs.Output(), "Usage: go run . [--output <path>]")
|
|
fmt.Fprintln(fs.Output(), "\nOptions:")
|
|
fmt.Fprintln(
|
|
fs.Output(),
|
|
" -o, --output <path> Where to write activity.json (default: activity.json)",
|
|
)
|
|
}
|
|
|
|
var output string
|
|
fs.StringVar(&output, "output", "activity.json", "Where to write activity.json")
|
|
fs.StringVar(&output, "o", "activity.json", "Where to write activity.json")
|
|
|
|
if err := fs.Parse(args); err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
os.Exit(0)
|
|
}
|
|
return "", err
|
|
}
|
|
if fs.NArg() > 0 {
|
|
return "", fmt.Errorf("unknown argument: %s", fs.Arg(0))
|
|
}
|
|
return output, nil
|
|
}
|
|
|
|
func loadConfig() config {
|
|
return config{
|
|
githubAPIKey: os.Getenv("GH_API_KEY"),
|
|
forgejoAPIKey: os.Getenv("FJ_API_KEY"),
|
|
forgejoUser: os.Getenv("FJ_USER"),
|
|
forgejoURL: envDefault("FJ_URL", "https://codeberg.org"),
|
|
gitlabAPIKey: os.Getenv("GL_API_KEY"),
|
|
gitlabUser: os.Getenv("GL_USER"),
|
|
gitlabURL: envDefault("GL_URL", "https://gitlab.com"),
|
|
}
|
|
}
|
|
|
|
func envDefault(key, fallback string) string {
|
|
if value := os.Getenv(key); value != "" {
|
|
return value
|
|
}
|
|
return fallback
|
|
}
|
|
|
|
func loadDotEnv() error {
|
|
paths := []string{".env"}
|
|
if info, err := os.Stat("get_history"); err == nil && info.IsDir() {
|
|
paths = append(paths, filepath.Join("get_history", ".env"))
|
|
}
|
|
loaded := map[string]bool{}
|
|
|
|
for _, path := range paths {
|
|
if loaded[path] {
|
|
continue
|
|
}
|
|
loaded[path] = true
|
|
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
continue
|
|
}
|
|
return fmt.Errorf("read %s: %w", path, err)
|
|
}
|
|
if err := parseDotEnv(string(data)); err != nil {
|
|
return fmt.Errorf("parse %s: %w", path, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func parseDotEnv(contents string) error {
|
|
for lineNumber, rawLine := range strings.Split(contents, "\n") {
|
|
line := strings.TrimSpace(strings.TrimSuffix(rawLine, "\r"))
|
|
if line == "" || strings.HasPrefix(line, "#") {
|
|
continue
|
|
}
|
|
line = strings.TrimSpace(strings.TrimPrefix(line, "export "))
|
|
|
|
key, value, ok := strings.Cut(line, "=")
|
|
if !ok {
|
|
return fmt.Errorf("line %d: expected KEY=VALUE", lineNumber+1)
|
|
}
|
|
|
|
key = strings.TrimSpace(key)
|
|
if key == "" {
|
|
return fmt.Errorf("line %d: empty key", lineNumber+1)
|
|
}
|
|
|
|
value = strings.TrimSpace(value)
|
|
if len(value) >= 2 {
|
|
quote := value[0]
|
|
if (quote == '\'' || quote == '"') && value[len(value)-1] == quote {
|
|
value = value[1 : len(value)-1]
|
|
}
|
|
}
|
|
|
|
if _, exists := os.LookupEnv(key); !exists {
|
|
if err := os.Setenv(key, value); err != nil {
|
|
return fmt.Errorf("line %d: %w", lineNumber+1, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (a app) areGHVarsPresent() bool {
|
|
return strings.TrimSpace(a.config.githubAPIKey) != ""
|
|
}
|
|
|
|
func (a app) areFJVarsPresent() bool {
|
|
return strings.TrimSpace(a.config.forgejoAPIKey) != "" &&
|
|
strings.TrimSpace(a.config.forgejoUser) != ""
|
|
}
|
|
|
|
func (a app) areGLVarsPresent() bool {
|
|
return strings.TrimSpace(a.config.gitlabAPIKey) != "" &&
|
|
strings.TrimSpace(a.config.gitlabUser) != ""
|
|
}
|
|
|
|
func formatGitHubTime(t time.Time) string {
|
|
return t.UTC().Format("2006-01-02T15:04:05.000+00:00")
|
|
}
|
|
|
|
func buildGHQuery(from, to string) string {
|
|
return fmt.Sprintf(`{
|
|
viewer {
|
|
contributionsCollection(from: %q, to: %q) {
|
|
contributionCalendar {
|
|
weeks {
|
|
contributionDays {
|
|
date
|
|
contributionCount
|
|
}
|
|
}
|
|
}
|
|
commitContributionsByRepository(maxRepositories: 100) {
|
|
repository {
|
|
nameWithOwner
|
|
isMirror
|
|
}
|
|
contributions(first: 100) {
|
|
nodes {
|
|
occurredAt
|
|
commitCount
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}`, from, to)
|
|
}
|
|
|
|
func mergeInto(target, source activityMap) {
|
|
for day, repos := range source {
|
|
if _, ok := target[day]; !ok {
|
|
target[day] = dayContributions{}
|
|
}
|
|
for repo, count := range repos {
|
|
target[day][repo] += count
|
|
}
|
|
}
|
|
}
|
|
|
|
func repoBaseName(fullName string) string {
|
|
parts := strings.Split(fullName, "/")
|
|
if len(parts) > 1 {
|
|
return strings.ToLower(parts[1])
|
|
}
|
|
return strings.ToLower(fullName)
|
|
}
|
|
|
|
func deduplicateAcrossPlatforms(left, right activityMap) activityMap {
|
|
leftBaseNames := map[string]bool{}
|
|
for _, repos := range left {
|
|
for repo := range repos {
|
|
if repo != "private" {
|
|
leftBaseNames[repoBaseName(repo)] = true
|
|
}
|
|
}
|
|
}
|
|
|
|
sharedBaseNames := map[string]bool{}
|
|
for _, repos := range right {
|
|
for repo := range repos {
|
|
base := repoBaseName(repo)
|
|
if repo != "private" && leftBaseNames[base] {
|
|
sharedBaseNames[base] = true
|
|
}
|
|
}
|
|
}
|
|
|
|
result := activityMap{}
|
|
days := map[string]bool{}
|
|
for day := range left {
|
|
days[day] = true
|
|
}
|
|
for day := range right {
|
|
days[day] = true
|
|
}
|
|
|
|
for day := range days {
|
|
result[day] = dayContributions{}
|
|
leftDay := left[day]
|
|
rightDay := right[day]
|
|
|
|
for repo, count := range leftDay {
|
|
base := repoBaseName(repo)
|
|
if repo != "private" && sharedBaseNames[base] {
|
|
rightRepo := findRepoByBase(rightDay, base)
|
|
rightCount := 0
|
|
if rightRepo != "" {
|
|
rightCount = rightDay[rightRepo]
|
|
}
|
|
if count >= rightCount {
|
|
result[day][repo] = count
|
|
}
|
|
} else {
|
|
result[day][repo] += count
|
|
}
|
|
}
|
|
|
|
for repo, count := range rightDay {
|
|
base := repoBaseName(repo)
|
|
if repo != "private" && sharedBaseNames[base] {
|
|
leftRepo := findRepoByBase(leftDay, base)
|
|
leftCount := 0
|
|
if leftRepo != "" {
|
|
leftCount = leftDay[leftRepo]
|
|
}
|
|
if count > leftCount {
|
|
if leftRepo != "" {
|
|
delete(result[day], leftRepo)
|
|
}
|
|
result[day][repo] = count
|
|
}
|
|
} else {
|
|
result[day][repo] += count
|
|
}
|
|
}
|
|
|
|
if len(result[day]) == 0 {
|
|
delete(result, day)
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func findRepoByBase(repos dayContributions, base string) string {
|
|
for repo := range repos {
|
|
if repoBaseName(repo) == base {
|
|
return repo
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (a app) parseGitHubContributions(data []byte) (activityMap, error) {
|
|
var response struct {
|
|
Data struct {
|
|
Viewer struct {
|
|
ContributionsCollection struct {
|
|
ContributionCalendar struct {
|
|
Weeks []struct {
|
|
ContributionDays []struct {
|
|
Date string `json:"date"`
|
|
ContributionCount int `json:"contributionCount"`
|
|
} `json:"contributionDays"`
|
|
} `json:"weeks"`
|
|
} `json:"contributionCalendar"`
|
|
CommitContributionsByRepository []struct {
|
|
Repository struct {
|
|
NameWithOwner string `json:"nameWithOwner"`
|
|
IsMirror bool `json:"isMirror"`
|
|
} `json:"repository"`
|
|
Contributions struct {
|
|
Nodes []struct {
|
|
OccurredAt string `json:"occurredAt"`
|
|
CommitCount int `json:"commitCount"`
|
|
} `json:"nodes"`
|
|
} `json:"contributions"`
|
|
} `json:"commitContributionsByRepository"`
|
|
} `json:"contributionsCollection"`
|
|
} `json:"viewer"`
|
|
} `json:"data"`
|
|
}
|
|
if err := json.Unmarshal(data, &response); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
result := activityMap{}
|
|
calendarMap := map[string]int{}
|
|
collection := response.Data.Viewer.ContributionsCollection
|
|
for _, week := range collection.ContributionCalendar.Weeks {
|
|
for _, day := range week.ContributionDays {
|
|
if day.ContributionCount > 0 {
|
|
calendarMap[day.Date] = day.ContributionCount
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, repoEntry := range collection.CommitContributionsByRepository {
|
|
if repoEntry.Repository.IsMirror {
|
|
continue
|
|
}
|
|
repoName := repoEntry.Repository.NameWithOwner
|
|
for _, contribution := range repoEntry.Contributions.Nodes {
|
|
day := strings.Split(contribution.OccurredAt, "T")[0]
|
|
if _, ok := result[day]; !ok {
|
|
result[day] = dayContributions{}
|
|
}
|
|
result[day][repoName] += contribution.CommitCount
|
|
}
|
|
}
|
|
|
|
for day, total := range calendarMap {
|
|
known := 0
|
|
for _, count := range result[day] {
|
|
known += count
|
|
}
|
|
hidden := total - known
|
|
if hidden > 0 {
|
|
if _, ok := result[day]; !ok {
|
|
result[day] = dayContributions{}
|
|
}
|
|
result[day]["private"] += hidden
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (a app) parseForgejoActivity(activities []forgejoActivity) activityMap {
|
|
result := activityMap{}
|
|
|
|
for _, activity := range activities {
|
|
if activity.Repo.Mirror || activity.OpType != "commit_repo" {
|
|
continue
|
|
}
|
|
|
|
displayName := activity.Repo.FullName
|
|
if activity.Repo.Private {
|
|
displayName = "private"
|
|
}
|
|
if displayName == "" {
|
|
displayName = "unknown"
|
|
}
|
|
|
|
var content struct {
|
|
Commits []struct {
|
|
Timestamp any `json:"Timestamp"`
|
|
} `json:"Commits"`
|
|
}
|
|
if err := json.Unmarshal([]byte(activity.Content), &content); err != nil {
|
|
continue
|
|
}
|
|
|
|
for _, commit := range content.Commits {
|
|
day, ok := forgejoCommitDay(commit.Timestamp)
|
|
if !ok {
|
|
continue
|
|
}
|
|
if _, exists := result[day]; !exists {
|
|
result[day] = dayContributions{}
|
|
}
|
|
result[day][displayName]++
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
type forgejoActivity struct {
|
|
OpType string `json:"op_type"`
|
|
Content string `json:"content"`
|
|
Repo struct {
|
|
Mirror bool `json:"mirror"`
|
|
Private bool `json:"private"`
|
|
FullName string `json:"full_name"`
|
|
} `json:"repo"`
|
|
}
|
|
|
|
func forgejoCommitDay(timestamp any) (string, bool) {
|
|
switch value := timestamp.(type) {
|
|
case float64:
|
|
return time.Unix(int64(value), 0).UTC().Format("2006-01-02"), true
|
|
case string:
|
|
if value == "" {
|
|
return "", false
|
|
}
|
|
return strings.Split(value, "T")[0], true
|
|
default:
|
|
return "", false
|
|
}
|
|
}
|
|
|
|
func (a app) getForgejoActivityMap() (activityMap, error) {
|
|
const pageLimit = 50
|
|
page := 1
|
|
result := activityMap{}
|
|
|
|
for {
|
|
url := fmt.Sprintf(
|
|
"%s/api/v1/users/%s/activities/feeds?limit=%d&page=%d&after=%s",
|
|
strings.TrimRight(a.config.forgejoURL, "/"),
|
|
a.config.forgejoUser,
|
|
pageLimit,
|
|
page,
|
|
a.formattedOneYearAgo,
|
|
)
|
|
body, err := a.doJSONRequest(
|
|
http.MethodGet,
|
|
url,
|
|
nil,
|
|
map[string]string{"Authorization": "Bearer " + a.config.forgejoAPIKey},
|
|
"Forgejo",
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var activities []forgejoActivity
|
|
if err := json.Unmarshal(body, &activities); err != nil {
|
|
return nil, err
|
|
}
|
|
if len(activities) == 0 {
|
|
break
|
|
}
|
|
|
|
mergeInto(result, a.parseForgejoActivity(activities))
|
|
if len(activities) < pageLimit {
|
|
break
|
|
}
|
|
page++
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (a app) ghFetch(query string) ([]byte, error) {
|
|
payload, err := json.Marshal(map[string]string{"query": query})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a.doJSONRequest(
|
|
http.MethodPost,
|
|
"https://api.github.com/graphql",
|
|
payload,
|
|
map[string]string{
|
|
"Content-Type": "application/json",
|
|
"Authorization": "Bearer " + a.config.githubAPIKey,
|
|
},
|
|
"GitHub",
|
|
)
|
|
}
|
|
|
|
func (a app) getGitHubActivityMap() (activityMap, error) {
|
|
type dateRange struct{ from, to string }
|
|
ranges := make([]dateRange, 12)
|
|
for i := range ranges {
|
|
to := a.now.AddDate(0, -i, 0)
|
|
from := to.AddDate(0, -1, 0)
|
|
ranges[i] = dateRange{from: toISO(from), to: toISO(to)}
|
|
}
|
|
|
|
result := activityMap{}
|
|
var mu sync.Mutex
|
|
var wg sync.WaitGroup
|
|
errCh := make(chan error, len(ranges))
|
|
|
|
for _, r := range ranges {
|
|
r := r
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
body, err := a.ghFetch(buildGHQuery(r.from, r.to))
|
|
if err != nil {
|
|
errCh <- err
|
|
return
|
|
}
|
|
parsed, err := a.parseGitHubContributions(body)
|
|
if err != nil {
|
|
errCh <- err
|
|
return
|
|
}
|
|
mu.Lock()
|
|
mergeInto(result, parsed)
|
|
mu.Unlock()
|
|
}()
|
|
}
|
|
|
|
wg.Wait()
|
|
close(errCh)
|
|
for err := range errCh {
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func toISO(t time.Time) string {
|
|
return t.UTC().Format("2006-01-02T15:04:05.000Z")
|
|
}
|
|
|
|
type gitlabEvent struct {
|
|
CreatedAt string `json:"created_at"`
|
|
AuthorUsername string `json:"author_username"`
|
|
TargetTitle string `json:"target_title"`
|
|
PushData *struct {
|
|
Action string `json:"action"`
|
|
CommitCount int `json:"commit_count"`
|
|
CommitTo string `json:"commit_to"`
|
|
} `json:"push_data"`
|
|
Project *struct {
|
|
PathWithNamespace string `json:"path_with_namespace"`
|
|
Visibility string `json:"visibility"`
|
|
} `json:"project"`
|
|
}
|
|
|
|
func parseGitLabEvents(events []gitlabEvent) activityMap {
|
|
result := activityMap{}
|
|
|
|
for _, event := range events {
|
|
if event.PushData == nil || event.PushData.Action == "deleted" {
|
|
continue
|
|
}
|
|
|
|
commitCount := 0
|
|
if event.PushData.CommitCount > 0 {
|
|
commitCount = event.PushData.CommitCount
|
|
} else if event.PushData.CommitTo != "" {
|
|
commitCount = 1
|
|
}
|
|
if commitCount == 0 {
|
|
continue
|
|
}
|
|
|
|
repoFullName := "unknown"
|
|
isPrivate := false
|
|
if event.Project != nil {
|
|
if event.Project.PathWithNamespace != "" {
|
|
repoFullName = event.Project.PathWithNamespace
|
|
}
|
|
isPrivate = event.Project.Visibility == "private"
|
|
} else if event.AuthorUsername != "" && event.TargetTitle != "" {
|
|
repoFullName = event.AuthorUsername + "/" + event.TargetTitle
|
|
}
|
|
|
|
displayName := repoFullName
|
|
if isPrivate {
|
|
displayName = "private"
|
|
}
|
|
day := strings.Split(event.CreatedAt, "T")[0]
|
|
if _, ok := result[day]; !ok {
|
|
result[day] = dayContributions{}
|
|
}
|
|
result[day][displayName] += commitCount
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func (a app) getGitLabActivityMap() (activityMap, error) {
|
|
const pageLimit = 100
|
|
page := 1
|
|
result := activityMap{}
|
|
afterDate := a.oneYearAgo.UTC().Format("2006-01-02")
|
|
|
|
for {
|
|
url := fmt.Sprintf(
|
|
"%s/api/v4/users/%s/events?action=pushed&after=%s&per_page=%d&page=%d",
|
|
strings.TrimRight(a.config.gitlabURL, "/"),
|
|
a.config.gitlabUser,
|
|
afterDate,
|
|
pageLimit,
|
|
page,
|
|
)
|
|
body, err := a.doJSONRequest(
|
|
http.MethodGet,
|
|
url,
|
|
nil,
|
|
map[string]string{"PRIVATE-TOKEN": a.config.gitlabAPIKey},
|
|
"GitLab",
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var events []gitlabEvent
|
|
if err := json.Unmarshal(body, &events); err != nil {
|
|
return nil, err
|
|
}
|
|
if len(events) == 0 {
|
|
break
|
|
}
|
|
|
|
mergeInto(result, parseGitLabEvents(events))
|
|
if len(events) < pageLimit {
|
|
break
|
|
}
|
|
page++
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (a app) makeActivityMap() (activityMap, error) {
|
|
type source struct {
|
|
name string
|
|
configured bool
|
|
fetch func() (activityMap, error)
|
|
}
|
|
|
|
sources := []source{
|
|
{name: "Github", configured: a.areGHVarsPresent(), fetch: a.getGitHubActivityMap},
|
|
{name: "Forgejo", configured: a.areFJVarsPresent(), fetch: a.getForgejoActivityMap},
|
|
{name: "Gitlab", configured: a.areGLVarsPresent(), fetch: a.getGitLabActivityMap},
|
|
}
|
|
|
|
results := make([]activityMap, len(sources))
|
|
var wg sync.WaitGroup
|
|
errCh := make(chan error, len(sources))
|
|
|
|
for i, source := range sources {
|
|
i, source := i, source
|
|
if !source.configured {
|
|
fmt.Printf("%s not configured, skipping...\n", source.name)
|
|
results[i] = activityMap{}
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("Fetching %s activity\n", source.name)
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
result, err := source.fetch()
|
|
if err != nil {
|
|
errCh <- err
|
|
return
|
|
}
|
|
results[i] = result
|
|
}()
|
|
}
|
|
|
|
wg.Wait()
|
|
close(errCh)
|
|
for err := range errCh {
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
merged := deduplicateAcrossPlatforms(results[0], results[1])
|
|
return deduplicateAcrossPlatforms(merged, results[2]), nil
|
|
}
|
|
|
|
func (a app) doJSONRequest(
|
|
method, url string,
|
|
body []byte,
|
|
headers map[string]string,
|
|
apiName string,
|
|
) ([]byte, error) {
|
|
var reader io.Reader
|
|
if body != nil {
|
|
reader = bytes.NewReader(body)
|
|
}
|
|
|
|
req, err := http.NewRequest(method, url, reader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for key, value := range headers {
|
|
req.Header.Set(key, value)
|
|
}
|
|
|
|
resp, err := a.client.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
respBody, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
|
return nil, fmt.Errorf("%s API error: %d %s", apiName, resp.StatusCode, resp.Status)
|
|
}
|
|
return respBody, nil
|
|
}
|
|
|
|
func (m activityMap) MarshalJSON() ([]byte, error) {
|
|
type day struct {
|
|
key string
|
|
val dayContributions
|
|
}
|
|
days := make([]day, 0, len(m))
|
|
for key, val := range m {
|
|
days = append(days, day{key: key, val: val})
|
|
}
|
|
sort.Slice(days, func(i, j int) bool { return days[i].key < days[j].key })
|
|
|
|
var buf bytes.Buffer
|
|
buf.WriteByte('{')
|
|
for i, day := range days {
|
|
if i > 0 {
|
|
buf.WriteByte(',')
|
|
}
|
|
key, _ := json.Marshal(day.key)
|
|
val, err := json.Marshal(day.val)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
buf.Write(key)
|
|
buf.WriteByte(':')
|
|
buf.Write(val)
|
|
}
|
|
buf.WriteByte('}')
|
|
return buf.Bytes(), nil
|
|
}
|