ch4/ch4-05 #158

2023-01-11T06:59:48Z

giscus[bot]
bot Jan 11, 2023

ch4/ch4-05

中文版

https://gopl-zh.github.io/ch4/ch4-05.html

zhangbest5 · 2023-01-11T06:59:51Z

zhangbest5
Jan 11, 2023 — with giscus

%-5d 最小宽度5，左对齐
%9.9s 最小宽度9，最大宽度9（超了截取）
%.55s 最小宽度无，最大宽度55（超了截取）

0 replies

xianren68 · 2023-04-25T12:44:55Z

xianren68
Apr 25, 2023 — with giscus

4.10

github.go

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"time"
)

// 网址
const Base_url = "https://api.github.com/search/issues"

// 用户
type User struct {
	// 用户名
	Login string `json:login`
	// 用户id
	Id int `json:id`
	// 用户主页
	HTMLURL string `json:html_url`
}

type Issue struct {
	Number    int
	HTMLURL   string `json:"html_url"`
	Title     string
	State     string
	User      *User
	CreatedAt time.Time `json:"created_at"`
	Body      string    // in Markdown format
}

type IssuesSearchResult struct {
	TotalCount int `json:"total_count"`
	Items      []*Issue
}

// 获取数据
func SearchIssure(term []string) (*IssuesSearchResult, error) {
	q := url.QueryEscape(strings.Join(term, " "))
	resp, err := http.Get(Base_url + "?q=" + q)
	if err != nil {
		return nil, err
	}
	// 判断状态码
	if resp.StatusCode != http.StatusOK {
		resp.Body.Close()
		return nil, fmt.Errorf("状态码错误：%d", resp.StatusCode)
	}
	var result = &IssuesSearchResult{}
	if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
		resp.Body.Close()
		return nil, err
	}
	resp.Body.Close()
	return result, nil

}

// 处理数据
func Process(data *IssuesSearchResult) {
	// 创建一个hash表
	hash := make(map[string][]*Issue, 3)
	hash["不到一月"] = make([]*Issue, 0)
	hash["不到一年"] = make([]*Issue, 0)
	hash["超过一年"] = make([]*Issue, 0)
	// 遍历数据
	for _, val := range data.Items {
		// 获取现在的时间
		now := time.Now()
		year := now.Year()
		month := now.Month()
		// 创建时间
		create_year := val.CreatedAt.Year()
		create_month := val.CreatedAt.Month()
		if year == create_year && month == create_month {
			hash["不到一月"] = append(hash["不到一月"], val)
		} else if year == create_year {
			hash["不到一年"] = append(hash["不到一年"], val)
		} else {
			hash["超过一年"] = append(hash["超过一年"], val)
		}
	}
	fmt.Printf("数据总条数，%v\n", data.TotalCount)
	for key, val := range hash {
		fmt.Printf("%s:\n", key)
		for _, v := range val {
			fmt.Printf("#%-5d %9.9s %.55s %9.9v\n",
				v.Number, v.User.Login, v.Title, v.CreatedAt)
		}
	}
}

main.go

func main() {
	query := os.Args[1:]
	data, err := test.SearchIssure(query)
	if err != nil {
		fmt.Println(err)
		return
	}
	test.Process(data)
}

4 replies

lyb88999 Apr 2, 2024 — with giscus

我觉得判断时间这里逻辑可能有点问题
这样是不是更好点

// 创建一个hash表
	hash := make(map[string][]*Issue, 3)
	hash["不到一月"] = make([]*Issue, 0)
	hash["不到一年"] = make([]*Issue, 0)
	hash["超过一年"] = make([]*Issue, 0)
	for _, val := range data.Items {
		// 计算从创建时间到现在的持续时间
		duration := time.Since(val.CreatedAt)

		if duration.Hours() < 24*30 { // 假设每月30天
			hash["不到一月"] = append(hash["不到一月"], val)
		} else if duration.Hours() < 24*365 { // 假设每年365天
			hash["不到一年"] = append(hash["不到一年"], val)
		} else {
			hash["超过一年"] = append(hash["超过一年"], val)
		}
	}

xianren68 Apr 2, 2024

确实有问题，想的简单了

lyb88999 Apr 3, 2024 — with giscus

已经很好了！我得看着您的代码我才有思路

xianren68 Apr 3, 2024

哈哈，咱们互相学习

xianren68 · 2023-04-26T13:07:42Z

xianren68
Apr 26, 2023 — with giscus

4.12

test.go

package test

import (
	"encoding/csv"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
)

// 定义用于接受的结构体
type Xkcd struct {
	// 标题
	Title string
	// 链接
	Link string
	// 封面
	Img string
}

// 地址
const Base_url = `https://xkcd.com/`

// 获取漫画信息并存到csv文件中作为离线索引
func GetSaveInfo() {
	// 创建文件
	f, err := os.Create("./xkcd.csv")
	if err != nil {
		fmt.Println("创建文件失败")
	}
	// 关闭文件
	defer f.Close()
	writer := csv.NewWriter(f)
	// 写入表头
	writer.Write([]string{"title", "link", "img"})
	// 循环获取每条数据
	for i := 1; ; i++ {
		xkcd := &Xkcd{}
		url := fmt.Sprintf("%s%d/info.0.json", Base_url, i)
		resp, err := http.Get(url)
		if err != nil {
			fmt.Println(err)
		}
		// 判断状态码
		if resp.StatusCode != http.StatusOK {
			resp.Body.Close()
			fmt.Println("没有更多了")
			return
		}
		if err = json.NewDecoder(resp.Body).Decode(xkcd); err != nil {
			resp.Body.Close()
			fmt.Println(err)
		}
		resp.Body.Close()
		writer.Write([]string{xkcd.Title, xkcd.Link, xkcd.Img})
		// 将缓存中的内容写入到文件里
		writer.Flush()

	}

}

// 通过关键字返回链接
func ResLink(key string) {
	// 寻找离线索引
	f, err := os.Open("./xkcd.csv")
	if err != nil {
		fmt.Println("打开文件失败，查看是否有离线索引")
	}
	defer f.Close()
	reader := csv.NewReader(f)
	// 循环对比
	for {
		result, err := reader.Read()
		// 到达文件尾部
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Println(err)
		}
		if key == result[0] {
			fmt.Println(result[1])
			return
		}
	}
	fmt.Println("暂时没有此漫画")
}

main.go

func main() {
	// 获取离线列表
	// test.GetSaveInfo()
	key := os.Args[1:]
	test.ResLink(strings.Join(key, " "))

}

0 replies

zhaojundu123 · 2023-06-25T10:31:32Z

zhaojundu123
Jun 25, 2023 — with giscus

4.13

package main

import (
"fmt"
"log"
"net/http"
"os"
"io/ioutil"
"encoding/json"
)

// get movies from omdbapi.com
// http://www.omdbapi.com/?t=Guardians+of+the+Galaxy+Vol.+2&y=2017&apikey=9f693ec9
// movie name: Guardians of the Galaxy Vol. 2
func getMovieData(movieName string) ([]byte, error) {
url := "http://www.omdbapi.com/?t=" + movieName + "&apikey=9f693ec9"
resp, err := http.Get(url)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return ioutil.ReadAll(resp.Body)
}

// get poster url from movies json
func getPosterUrl(movieJson []byte) (string, error) {
var movie struct {
Poster string json:"Poster"
}
err := json.Unmarshal(movieJson, &movie)
if err != nil {
return "", err
}
return movie.Poster, nil
}

// download poster from url
func main(){
movieName := os.Args[1]
movieJson, err := getMovieData(movieName)
if err != nil {
log.Fatal(err)
}
posterUrl, err := getPosterUrl(movieJson)
if err != nil {
log.Fatal(err)
}
fmt.Println(posterUrl)
resp, err := http.Get(posterUrl)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil{
log.Fatal(err)
}
err = ioutil.WriteFile("poster.jpg", body, 0644)
if err != nil {
log.Fatal(err)
}
fmt.Println("poster.jpg downloaded")
}

1 reply

zhaojundu123 Jun 25, 2023 — with giscus

需要先申请自己的API KEY，进行替换

SuperZ3 · 2023-11-01T03:13:17Z

SuperZ3
Nov 1, 2023 — with giscus

从下往上看👁

package main

import (
	"time"
	"encoding/json"
	"fmt"
	"net/http"
    "net/url"
    "strings"
	"log"
    "os"
	"bufio"
	"io/ioutil"
	"regexp"
	"io"
	"flag"
	"os/exec"
)

const IssuesURL = "https://api.github.com/search/issues"

type IssuesSearchResult struct {
    TotalCount int `json:"total_count"`
    Items          []*Issue
}

type Issue struct {
    Number    int
    HTMLURL   string `json:"html_url"`
    Title     string
    State     string
    User      *User
    CreatedAt time.Time `json:"created_at"`
    Body      string 
}

type User struct {
    Login   string
    HTMLURL string `json:"html_url"`
}

type PosterResp struct {
	Poster string
	Title string
}

type XkcdResp struct {
	Img string
	Title string
	Link string
}

func SearchIssues(terms []string) (*IssuesSearchResult, error) {
	q := url.QueryEscape(strings.Join(terms, " "))
	fmt.Println(IssuesURL + "?q=" + q)
	resp, err := http.Get(IssuesURL + "?q=" + q)
	if err != nil {
		return nil, err
	}

	if resp.StatusCode != http.StatusOK {
        resp.Body.Close()
        return nil, fmt.Errorf("search query failed: %s", resp.Status)
    }

	var result IssuesSearchResult
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        resp.Body.Close()
        return nil, err
    }
    resp.Body.Close()
    return &result, nil
}

func CategorizedCreatedAt(issues []*Issue) {
	now := time.Now().UTC()
	var OverYear, LessYear, LessMonth []*Issue

	for _, issue := range issues {
		issueTime := issue.CreatedAt.UTC()
		isOverOneYear := now.Year() - issueTime.Year() > 1
		isLessOneMonth := !isOverOneYear && (now.Month() - issueTime.Month() < 1)
		if isOverOneYear {
			OverYear = append(OverYear, issue)
		} else if !isOverOneYear {
			LessYear = append(LessYear, issue)
		} else if isLessOneMonth {
			LessMonth = append(LessMonth, issue)
		}
	}
	for _, issue := range OverYear {
		fmt.Printf("Over one Year: #%-5d %9.9s %.55s\n", issue.Number, issue.User.Login, issue.Title)
	}
	for _, issue := range LessYear {
		fmt.Printf("Less one Year: #%-5d %9.9s %.55s\n", issue.Number, issue.User.Login, issue.Title)
	}
	for _, issue := range LessMonth {
		fmt.Printf("Less one Month: #%-5d %9.9s %.55s\n", issue.Number, issue.User.Login, issue.Title)
	}

}

func parseBody(response *http.Response) ([]byte, error) {
	body, err := ioutil.ReadAll(response.Body)
	return body, err
}

func queryUrl(url string) ([]byte, error) {
	// 1. query url
	resp, err := http.Get(url)
	if err != nil || resp.StatusCode != http.StatusOK {
		fmt.Printf("query url error: %v", err)
		return nil, err
	}
	// 2. parse response body
	body, err := parseBody(resp)
    if err != nil {
		fmt.Printf("parse response error: %v", err)
        return nil, err
    }
	defer resp.Body.Close()
	return body, nil
}

func Poster() {
	// 1. get movie name
	// you can apply free apiKey
	ImageUrl := "http://www.omdbapi.com/?apikey=[your key]&"
	fmt.Println("---------------- Input move name ----------------------------")
	reader := bufio.NewReader(os.Stdin)
	movieName, _, err := reader.ReadLine()
	if err != nil {
		fmt.Println("cannot get movie name")
		return
	}
	// 2. query movie info
	escapeName := url.QueryEscape(string(movieName))
	movieUrl := ImageUrl + "&plot=full&t=" + escapeName
	movieBody, err := queryUrl(movieUrl)
	if err != nil {
		return
	}
	// 3. download image
	var jsonMovieBody PosterResp
	json.Unmarshal(movieBody, &jsonMovieBody)
	imgUrl := jsonMovieBody.Poster
	imgBody, err := queryUrl(imgUrl)
	if err != nil {
		return
	}
	// 4. write file
	var validSuffix = regexp.MustCompile(`\.(jpe?g|web|png|gif)$`)
	suffix := validSuffix.FindString(imgUrl)
	fileName := string(movieName) + suffix
	fileErr := ioutil.WriteFile(fileName, imgBody, 0644)
	if fileErr != nil {
		log.Fatal(fileErr)
	}
}

func Xkcd() {
	xkcdUrl := "https://xkcd.com/"
	xkcdSuffix := "/info.0.json"
	f, err := os.OpenFile("storage.txt", os.O_RDWR|os.O_CREATE, 0666)
	if err != nil {
		log.Fatal(err)
	}

	var max int
	fmt.Println("------------------- how match you want -----------------------")
	fmt.Scanln(&max)

	for i := 1; i < max; i++ {
		url := xkcdUrl + fmt.Sprint(i) + xkcdSuffix
		fmt.Printf("query url: %v\n", url)
		body, err := queryUrl(url)
		if err != nil {
			fmt.Printf("query url error: %v\n", err)
			break
		}
		var parseBody XkcdResp
		if err := json.Unmarshal(body, &parseBody); err != nil {
			log.Fatalf("JSON unmarshaling failed: %s", err)
			continue
		}
		row := parseBody.Img + parseBody.Title + parseBody.Link + "\n"
		if _, err := f.Write([]byte(row)); err != nil {
			fmt.Printf("write info error: %v\n", err)
		}
	}
	f.Close()

	rf, rErr := os.OpenFile("storage.txt", os.O_RDONLY, 0)
	if rErr != nil {
		log.Fatal(err)
	}

	var order int
	fmt.Println("------------------- want order -----------------------")
	fmt.Scanln(&order)

	reader := bufio.NewReader(rf)
	flag := 0
	for {
		line, err := reader.ReadString('\n')
		if err != nil {
			if err == io.EOF {
				fmt.Printf("EOF: %#v\n", line)
				break
			}
		}
		if flag == order - 1 {
			fmt.Printf("%v", line)
		}
		flag++
	}

	defer f.Close()
}

func queryIssue(address, method string) {
	// 1. generator template
	f, err := os.OpenFile("template.txt", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
	if err != nil {
		log.Fatal(err)
		return
	}
	template := "title:\nbody:\nstate:\n"
	_, wErr := f.WriteString(template)
	if err != nil {
		fmt.Printf("generator template error: %v", wErr)
		return
	}
	f.Close()

	// 2. open template, waiting for user write
	// Attention: use case run on mac os
	cmd := exec.Command("open", "template.txt")
	if err := cmd.Run(); err != nil {
		os.Exit(1)
		log.Fatal(err)
		return
	}

	var moveOn string
	fmt.Println("-- waiting fo input title, body and state, type continue to move on --")
	fmt.Scanln(&moveOn)
	for moveOn != "continue" {}

	// 3. read template, get title body etc.
	f, ferr := os.OpenFile("template.txt", os.O_RDONLY, 0666)
	if ferr != nil {
		log.Fatal(ferr)
		return
	}
	reader := bufio.NewReader(f)
	lines := make(map[string]string)
	for {
		line, _, err := reader.ReadLine()
		if err != nil {
			if err == io.EOF {
				break
			}
			return
		}
		parseLine := string(line)
		if strings.Contains(parseLine, ":") {
			arr := strings.Split(parseLine, ":")
			if arr[1] != "" {
				lines[arr[0]] = arr[1]
			}
		}
	}
	defer f.Close()

	if len(lines) > 0 {
		jsonBytes, err := json.MarshalIndent(lines, "", " ")
		if err != nil {
			log.Fatal(err)
		}

		client := &http.Client{}
		req, err := http.NewRequest(method, address, strings.NewReader(string(jsonBytes)))
		req.Header.Add("Content-Type", "application/json")
		// https://docs.github.com/en/rest/overview/authenticating-to-the-rest-api?apiVersion=2022-11-28
		req.Header.Add("Authorization", "Bearer [your token]")
		resp, err := client.Do(req)
		body, _ := ioutil.ReadAll(resp.Body)
		fmt.Printf("%v \n %v \n %v", address, string(body), strings.NewReader(string(jsonBytes)))
		if err != nil {
			fmt.Printf("Error: %v\n", err)
			return
		}
		if resp.StatusCode == http.StatusOK {
			fmt.Printf("Success: %v", string(body))
		}
		defer resp.Body.Close()
	} else {
		fmt.Println("nothing input, quit")
	}
}

func IssueOperation() {
	var owner string
	var repo string
	var issueNumber string
	var operationType int
	const OperationURL = "https://api.github.com/repos/"
	flag.IntVar(&operationType, "operation", 0, "Specify operation type: 1 -- create; 2 -- get; 3 -- update; 4 -- delete")
	flag.StringVar(&owner, "owner", "", "The account owner of the repository. The name is not case sensitive.")
	flag.StringVar(&repo, "repo", "", "The name of the repository without the .git extension. The name is not case sensitive.")
	flag.StringVar(&issueNumber, "issue_n", "", "The number that identifies the issue.")
	flag.Parse()
	
	if owner != "" && repo != "" && operationType != 0 {
		var queryAddress string

		switch operationType {
			case 1:
				// command: go run hello.go -operation=1 -owner=[your owner] -repo=[your repo]
				queryAddress = OperationURL + owner + "/" + repo + "/issues"
				queryIssue(queryAddress, "POST")
			case 2:
				// command go run hello.go -operation=2 -owner=golang -repo=go -issue_n=5680
				queryAddress = OperationURL + owner + "/" + repo + "/issues/" + issueNumber
				body, err := queryUrl(queryAddress)
				if err != nil {
					fmt.Printf("get issue error: %v\n", err)
					return
				}
				var result Issue
				parseErr := json.Unmarshal(body, &result)
				if parseErr != nil {
					fmt.Printf("parse body error: %v", parseErr)
					return
				}
				fmt.Println(result)
			case 3:
				// command: go run hello.go -operation=3 -owner=[your owner] -repo=[your repo] -issue_n=1
				queryAddress = OperationURL + owner + "/" + repo + "/issues/" + issueNumber
				queryIssue(queryAddress, "PATCH")
			case 4:
				// command: go run hello.go -operation=4 -owner=[your owner] -repo=[your repo] -issue_n=1
				// set state -> 4
				queryAddress = OperationURL + owner + "/" + repo + "/issues/" + issueNumber
				queryIssue(queryAddress, "PATCH")
		}
	} else {
		fmt.Println("application need correct input")
	}
}

func main() {
	result, err := SearchIssues(os.Args[1:])
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%d issues:\n", result.TotalCount)
	for _, item := range result.Items {
        fmt.Printf("#%-5d %9.9s %.55s\n",
            item.Number, item.User.Login, item.Title)
    }

	// Remember to comment other code
	fmt.Println("---------------- 4.10 Categorized by time start -----------------")
	CategorizedCreatedAt(result.Items)
	fmt.Println("---------------- 4.10 Categorized by time end -------------------")

	// Remember to comment other code
	fmt.Println("---------------- 4.11 Issue start -----------------")
	IssueOperation()
	fmt.Println("---------------- 4.11 Issue end -------------------")

	// Remember to comment other code
	fmt.Println("---------------- 4.12 xkcd start -----------------")
	Xkcd()
	fmt.Println("---------------- 4.12 xkcd end -------------------")

	// Remember to comment other code
	fmt.Println("---------------- 4.13 Poster start -----------------")
	Poster()
	fmt.Println("---------------- 4.13 Poster end -------------------")
}

0 replies

lyb88999 · 2024-04-03T02:41:42Z

lyb88999
Apr 3, 2024 — with giscus

4.13

func Poster(filmName string) (*Film, error) {
	// 安全地编码电影名称
	safeFilmName := url.QueryEscape(filmName)
	requestURL := fmt.Sprintf("%s?apikey=9f693ec9&t=%s", BaseUrl, safeFilmName)

	resp, err := http.Get(requestURL)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("search query failed: %s", resp.Status)
	}

	var film Film
	if err := json.NewDecoder(resp.Body).Decode(&film); err != nil {
		return nil, err
	}

	if film.Poster == "" {
		return &film, fmt.Errorf("no poster URL found")
	}

	// 获取海报图像
	resp, err = http.Get(film.Poster)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("failed to get poster image")
	}

	img, err := jpeg.Decode(resp.Body)
	if err != nil {
		return nil, err
	}

	filePath := "./pic/" + film.Title + ".jpg"
	file, err := os.Create(filePath)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	if err = jpeg.Encode(file, img, &jpeg.Options{Quality: 75}); err != nil {
		return nil, err
	}

	fmt.Println("Poster saved to", filePath)
	return &film, nil
}

0 replies

hongjiala · 2025-03-07T07:06:09Z

hongjiala
Mar 7, 2025 — with giscus

// Issues prints a table of GitHub issues matching the search terms.
// Issues prints a table of GitHub issues matching the search terms.
练习 4.10：修改issues程序，根据问题的时间进行分类，比如不到一个月的、不到一年的、超过一年。
package main

import (
"fmt"
"log"
"os"
"time"

"hello.go/github"

)

func main() {
result, err := github.SearchIssues(os.Args[1:])
if err != nil {
log.Fatal(err)
}
fmt.Printf("%d issues:\n", result.TotalCount)

now := time.Now()
for _, item := range result.Items {
	// 如果创建时间在一周之内
	if item.CreatedAt.After(now.AddDate(0, 0, -7)) {
		fmt.Printf("#%-5d %9.9s %.55s 不到一周\n", item.Number, item.User.Login, item.Title)
	} else if item.CreatedAt.After(now.AddDate(0, -1, 0)) {
		// 如果创建时间在一周之前但在一个月之内
		fmt.Printf("#%-5d %9.9s %.55s 不到一个月\n", item.Number, item.User.Login, item.Title)
	} else {
		// 如果创建时间超过一个月
		fmt.Printf("#%-5d %9.9s %.55s 一个月以上\n", item.Number, item.User.Login, item.Title)
	}
}

}

0 replies

hongjiala · 2025-03-07T09:49:30Z

hongjiala
Mar 7, 2025 — with giscus

// Issues prints a table of GitHub issues matching the search terms.
// 练习 4.11：编写一个工具，允许用户在命令行创建、读取、更新和关闭GitHub上的issue，当必要的时候自动打开用户默认的编辑器用于输入文本信息。
package main

import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
"os"
"os/exec"
"strconv"
)

// Issue 定义了我们要提交给 GitHub API 的 issue 数据结构
type Issue struct {
Title string json:"title,omitempty"
Body string json:"body,omitempty"
State string json:"state,omitempty"
}

const baseURL = "https://api.github.com"

// getAuthToken 从环境变量中获取 GitHub 访问令牌
func getAuthToken() string {
token := os.Getenv("GITHUB_TOKEN")
if token == "" {
log.Fatal("请设置 GITHUB_TOKEN 环境变量")
}
return token
}

// getEditorInput 会新建一个临时文件，将 initial 内容写入后调用默认编辑器，编辑结束后返回文件内容
func getEditorInput(initial string) (string, error) {
tmpFile, err := ioutil.TempFile("", "issue_*.txt")
if err != nil {
return "", err
}
defer os.Remove(tmpFile.Name())

if initial != "" {
	if _, err = tmpFile.WriteString(initial); err != nil {
		return "", err
	}
	tmpFile.Sync()
}
tmpFile.Close()

editor := os.Getenv("EDITOR")
if editor == "" {
	editor = "Code"
}
cmd := exec.Command(editor, tmpFile.Name())
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr

if err = cmd.Run(); err != nil {
	return "", err
}

content, err := ioutil.ReadFile(tmpFile.Name())
if err != nil {
	return "", err
}
return string(content), nil

}

// createIssue 通过 GitHub API 创建 issue
func createIssue(owner, repo string) error {
// 读取标题
fmt.Print("请输入 issue 标题：")
var title string
fmt.Scanln(&title)

// 编辑正文
body, err := getEditorInput("")
if err != nil {
	return err
}

issue := Issue{Title: title, Body: body}
data, err := json.Marshal(issue)
if err != nil {
	return err
}

url := fmt.Sprintf("%s/repos/%s/%s/issues", baseURL, owner, repo)
req, err := http.NewRequest("POST", url, bytes.NewBuffer(data))
if err != nil {
	return err
}
req.Header.Set("Authorization", "token "+getAuthToken())
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
	return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusCreated {
	bodyBytes, _ := ioutil.ReadAll(resp.Body)
	return fmt.Errorf("创建 issue 失败：%s", string(bodyBytes))
}

fmt.Println("Issue 创建成功。")
return nil

}

// readIssue 读取指定 issue 信息
func readIssue(owner, repo string, number int) error {
url := fmt.Sprintf("%s/repos/%s/%s/issues/%d", baseURL, owner, repo, number)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return err
}
req.Header.Set("Authorization", "token "+getAuthToken())

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
	return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
	bodyBytes, _ := ioutil.ReadAll(resp.Body)
	return fmt.Errorf("读取 issue 失败：%s", string(bodyBytes))
}
bodyBytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
	return err
}
fmt.Println("Issue 信息：")
fmt.Println(string(bodyBytes))
return nil

}

// updateIssue 更新指定 issue 的标题和正文
func updateIssue(owner, repo string, number int) error {
// 先获取当前 issue 信息
url := fmt.Sprintf("%s/repos/%s/%s/issues/%d", baseURL, owner, repo, number)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return err
}
req.Header.Set("Authorization", "token "+getAuthToken())

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
	return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
	bodyBytes, _ := ioutil.ReadAll(resp.Body)
	return fmt.Errorf("读取 issue 失败：%s", string(bodyBytes))
}
bodyBytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
	return err
}

var current Issue
if err = json.Unmarshal(bodyBytes, &current); err != nil {
	return err
}

fmt.Printf("当前标题：%s\n", current.Title)
fmt.Print("请输入新的标题（留空保持不变）：")
var newTitle string
fmt.Scanln(&newTitle)
if newTitle == "" {
	newTitle = current.Title
}

newBody, err := getEditorInput(current.Body)
if err != nil {
	return err
}

updated := Issue{Title: newTitle, Body: newBody}
data, err := json.Marshal(updated)
if err != nil {
	return err
}

req, err = http.NewRequest("PATCH", url, bytes.NewBuffer(data))
if err != nil {
	return err
}
req.Header.Set("Authorization", "token "+getAuthToken())
req.Header.Set("Content-Type", "application/json")
resp, err = client.Do(req)
if err != nil {
	return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
	bodyBytes, _ := ioutil.ReadAll(resp.Body)
	return fmt.Errorf("更新 issue 失败：%s", string(bodyBytes))
}
fmt.Println("Issue 更新成功。")
return nil

}

// closeIssue 将指定 issue 状态设置为 closed
func closeIssue(owner, repo string, number int) error {
updated := Issue{State: "closed"}
data, err := json.Marshal(updated)
if err != nil {
return err
}
url := fmt.Sprintf("%s/repos/%s/%s/issues/%d", baseURL, owner, repo, number)
req, err := http.NewRequest("PATCH", url, bytes.NewBuffer(data))
if err != nil {
return err
}
req.Header.Set("Authorization", "token "+getAuthToken())
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
bodyBytes, _ := ioutil.ReadAll(resp.Body)
return fmt.Errorf("关闭 issue 失败：%s", string(bodyBytes))
}
fmt.Println("Issue 已关闭。")
return nil
}

func main() {
// 简单命令行参数解析
if len(os.Args) < 4 {
fmt.Println("用法示例：")
fmt.Println(" ghissue create ")
fmt.Println(" ghissue read <issue_number>")
fmt.Println(" ghissue update <issue_number>")
fmt.Println(" ghissue close <issue_number>")
os.Exit(1)
}

command := os.Args[1]
owner := os.Args[2]
repo := os.Args[3]

switch command {
case "create":
	if err := createIssue(owner, repo); err != nil {
		log.Fatal(err)
	}
case "read":
	if len(os.Args) < 5 {
		fmt.Println("读取 issue 时需要提供 issue 编号")
		os.Exit(1)
	}
	number, err := strconv.Atoi(os.Args[4])
	if err != nil {
		log.Fatal(err)
	}
	if err := readIssue(owner, repo, number); err != nil {
		log.Fatal(err)
	}
case "update":
	if len(os.Args) < 5 {
		fmt.Println("更新 issue 时需要提供 issue 编号")
		os.Exit(1)
	}
	number, err := strconv.Atoi(os.Args[4])
	if err != nil {
		log.Fatal(err)
	}
	if err := updateIssue(owner, repo, number); err != nil {
		log.Fatal(err)
	}
case "close":
	if len(os.Args) < 5 {
		fmt.Println("关闭 issue 时需要提供 issue 编号")
		os.Exit(1)
	}
	number, err := strconv.Atoi(os.Args[4])
	if err != nil {
		log.Fatal(err)
	}
	if err := closeIssue(owner, repo, number); err != nil {
		log.Fatal(err)
	}
default:
	fmt.Println("未知的命令:", command)
	os.Exit(1)
}

}

0 replies

hongjiala · 2025-03-07T10:14:25Z

hongjiala
Mar 7, 2025 — with giscus


package main

//练习 4.12： 流行的web漫画服务xkcd也提供了JSON接口。
// 例如，一个 https://xkcd.com/571/info.0.json 请求将返回一个很多人喜爱的571编号的详细描述。
// 下载每个链接（只下载一次）然后创建一个离线索引。编写一个xkcd工具，使用这些离线索引，打印和命令行输入的检索词相匹配的漫画的URL。

import (
	"fmt"
	"os"
	"strings"

	"hello.go/xtcd"
)

func main() {
	// 检查是否有足够的命令行参数
	if len(os.Args) < 2 {
		fmt.Println("用法：xkcd <查询关键词>")
		os.Exit(1)
	}
	// 将所有命令行参数合并成一个字符串，以空格分隔
	key := strings.Join(os.Args[1:], " ")

	// 获取数据（如果数据文件不存在则下载）
	if !xtcd.IsExist() {
		xtcd.GetSaveInfo()
	}
	// 读取数据
	data := xtcd.ReadInfo(key)
	// 打印数据
	if data != nil {
		xtcd.PrintInfo(data)
	} else {
		fmt.Println("没有找到")
	}
}

package xtcd

import (
	"encoding/csv"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

//练习 4.12： 流行的web漫画服务xkcd也提供了JSON接口。
// 例如，一个 https://xkcd.com/571/info.0.json 请求将返回一个很多人喜爱的571编号的详细描述。
// 下载每个链接（只下载一次）然后创建一个离线索引。编写一个xkcd工具，使用这些离线索引，打印和命令行输入的检索词相匹配的漫画的URL。

const URL = "https://xkcd.com/571/info.0.json"

// 定义用于接受的结构体
type Xkcd struct {
	// 标题
	Title string
	// 链接
	Link string
	// 封面
	Img string
}

// 地址
const Base_url = `https://xkcd.com/`

// 获取漫画信息并存到csv文件中作为离线索引
func GetSaveInfo() {
	// 创建文件
	f, err := os.Create("./xkcd.csv")
	if err != nil {
		fmt.Println("创建文件失败")
	}
	// 关闭文件
	defer f.Close()
	writer := csv.NewWriter(f)
	// 写入表头
	writer.Write([]string{"title", "link", "img"})
	// 循环获取每条数据
	for i := 1; ; i++ {
		xkcd := &Xkcd{}
		url := fmt.Sprintf("%s%d/info.0.json", Base_url, i)
		resp, err := http.Get(url)
		if err != nil {
			fmt.Println(err)
		}
		// 判断状态码
		if resp.StatusCode != http.StatusOK {
			resp.Body.Close()
			fmt.Println("没有更多了")
			return
		}
		if err = json.NewDecoder(resp.Body).Decode(xkcd); err != nil {
			resp.Body.Close()
			fmt.Println(err)
		}
		resp.Body.Close()
		writer.Write([]string{xkcd.Title, xkcd.Link, xkcd.Img})
		// 将缓存中的内容写入到文件里
		writer.Flush()

	}
}

func IsExist() bool {
	_, err := os.Stat("./xkcd.csv")
	return err == nil
}

func ReadInfo(key string) *Xkcd {
	// 打开文件
	f, err := os.Open("./xkcd.csv")
	if err != nil {
		fmt.Println("打开文件失败")
	}
	defer f.Close()
	reader := csv.NewReader(f)
	// 读取所有内容
	rows, err := reader.ReadAll()
	if err != nil {
		fmt.Println("读取文件失败")
	}
	// 循环遍历
	for _, row := range rows {
		if row[0] == key {
			return &Xkcd{
				Title: row[0],
				Link:  row[1],
				Img:   row[2],
			}
		}
	}
	return nil
}

func PrintInfo(data *Xkcd) {
	fmt.Printf("title: %s\nlink: %s\nimg: %s\n", data.Title, data.Link, data.Img)
}

0 replies

hongjiala · 2025-03-07T10:29:28Z

hongjiala
Mar 7, 2025 — with giscus

package poster

import (
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"os"
"strings"
)

// Movie 用于解析 OMDB 返回的 JSON 数据
type Movie struct {
Title string json:"Title"
Poster string json:"Poster"
Response string json:"Response"
Error string json:"Error"
}

const apiKey = "744303"

// GetPoster 根据电影名称和 API key 获取电影信息，并下载海报
func GetPoster(movieTitle, apiKey string) error {
// URL编码电影名称以处理空格和特殊字符
encodedTitle := url.QueryEscape(movieTitle)
// 构造查询 URL
fullURL := fmt.Sprintf("http://www.omdbapi.com/?apikey=%s&t=%s", apiKey, encodedTitle)

// 发送请求获取电影信息
resp, err := http.Get(fullURL)
if err != nil {
	return err
}
defer resp.Body.Close()

var movie Movie
if err := json.NewDecoder(resp.Body).Decode(&movie); err != nil {
	return err
}

if movie.Response != "True" {
	return fmt.Errorf("查询电影失败: %s", movie.Error)
}

// 检查海报 URL 是否有效
if movie.Poster == "N/A" || movie.Poster == "" {
	return fmt.Errorf("电影 [%s] 没有海报", movie.Title)
}

// 下载海报图像
posterResp, err := http.Get(movie.Poster)
if err != nil {
	return err
}
defer posterResp.Body.Close()

// 生成保存文件名，替换空格为下划线
fileName := fmt.Sprintf("%s.jpg", strings.ReplaceAll(movie.Title, " ", "_"))
file, err := os.Create(fileName)
if err != nil {
	return err
}
defer file.Close()

// 将下载的图像数据写入文件
_, err = io.Copy(file, posterResp.Body)
if err != nil {
	return err
}

fmt.Printf("海报已保存为 %s\n", fileName)
return nil

}
package main

import (
"fmt"
"os"
"strings"

"hello.go/poster" // 假设 poster 包在 GOPATH 中

)

const apiKey = "768403"

func main() {
// 检查命令行参数是否充足
if len(os.Args) < 2 {
fmt.Println("用法: poster <电影名称>")
os.Exit(1)
}

// 合并所有命令行参数，处理包含空格的情况
movieName := strings.Join(os.Args[1:], " ")
apiKey := "744303"

// 获取 API key（例如从环境变量中读取）
//apiKey := os.Getenv("OMDB_APIKEY")
if apiKey == "" {
	fmt.Println("请设置环境变量 OMDB_APIKEY")
	os.Exit(1)
}

if err := poster.GetPoster(movieName, apiKey); err != nil {
	fmt.Println("错误:", err)
	os.Exit(1)
}

}

0 replies

celiachu · 2025-04-02T04:00:58Z

celiachu
Apr 2, 2025 — with giscus

4.12

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strings"
)

type Comic struct {
	Num        int    `json:"num"`
	Title      string `json:"safe_title"`
	Alt        string `json:"alt"`
	Transcript string `json:"transcript"`
	Img        string `json:"img"`
}

const dir = "xkcd_data"

func main() {
	// comic, err := fetchComic(571)
	// if err != nil {
	// 	log.Fatal(err)
	// }
	// fmt.Printf("Title: %s\nAlt: %s\n", comic.Title, comic.Alt)

	// 示例：下载前 20 条测试用
	err := downloadAllComics(1, 20)
	if err != nil {
		log.Fatal(err)
	}
	if len(os.Args) < 2 {
		log.Fatal("请提供一个关键词作为搜索参数")
	}
	keyword := os.Args[1]
	comics, err := loadComics()
	if err != nil {
		log.Fatal(err)
	}

	matches := searchComics(comics, keyword)
	for _, comic := range matches {
		fmt.Printf("https://xkcd.com/%d/  -  %s\n", comic.Num, comic.Title)
	}
}

func fetchComic(num int) (*Comic, error) {
	url := fmt.Sprintf("https://xkcd.com/%d/info.0.json", num)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
	}
	var comic Comic
	if err := json.NewDecoder(resp.Body).Decode(&comic); err != nil {
		return nil, err
	}
	return &comic, err
}

func downloadAllComics(start, end int) error {
	os.MkdirAll(dir, os.ModePerm)

	for i := start; i <= end; i++ {
		num := i
		filename := fmt.Sprintf("%s/%d.json", dir, num)
		if _, err := os.Stat(filename); err == nil {
			// 文件已存在
			continue
		}
		comic, err := fetchComic(i)
		if err != nil {
			log.Printf("Failed to fetch comic %d: %v", num, err)
			continue // 忽略错误继续下一个
		}
		file, err := os.Create(filename)
		if err != nil {
			log.Printf("Failed to create file for comic %d: %v", num, err)
			continue
		}
		if err := json.NewEncoder(file).Encode(comic); err != nil {
			log.Printf("Failed to encode comic %d: %v", num, err)
		}
		file.Close()
	}
	return nil
}

func loadComics() ([]Comic, error) {
	entries, err := os.ReadDir(dir)
	if err != nil {
		return nil, err
	}
	var comics []Comic
	for _, entry := range entries {
		if !strings.HasSuffix(entry.Name(), ".json") {
			continue
		}
		file, err := os.Open(filepath.Join(dir, entry.Name()))
		if err != nil {
			log.Printf("error: %v", err)
			continue
		}
	
		var comic Comic
		err = json.NewDecoder(file).Decode(&comic)
		if err != nil {
			log.Printf("error: %v", err)
		}
		comics = append(comics, comic)
			file.Close()
	}
	return comics, nil

}

func searchComics(comics []Comic, keyword string) []Comic {
	lowerKeyword := strings.ToLower(keyword)
	var results []Comic
	for _, comic := range comics {
		content := comic.Title + " " + comic.Alt + " " + comic.Transcript
		content = strings.ToLower(content)
		if strings.Contains(content, lowerKeyword) {
			results = append(results, comic)
		}
	}
	return results
}

0 replies

pyhita · 2025-06-21T12:09:19Z

pyhita
Jun 21, 2025 — with giscus

exercise 4.10

func makeType(createAt time.Time) IssueType {
	if isOneYear(createAt) {
		return OneYear
	}
	if isOneMonth(createAt) {
		return OneMonth
	}

	return Others
}

func isOneMonth(createAt time.Time) bool {
	now := time.Now()
	oneMonthLater := createAt.AddDate(0, 1, 0)

	return now.Before(oneMonthLater) || now.Equal(oneMonthLater)
}

func isOneYear(createAt time.Time) bool {
	now := time.Now()
	oneYearLater := createAt.AddDate(1, 0, 0)
	return now.Before(oneYearLater) || now.Equal(oneYearLater)
}

func isOthers(createAt time.Time) bool {
	return !isOneYear(createAt) && !isOneMonth(createAt)
}

// 练习 4.10： 修改issues程序，根据问题的时间进行分类，比如不到一个月的、不到一年的、超过一年。

func main() {
	result, err := github.SearchIssues(os.Args[1:])
	if err != nil {
		log.Fatal(err)
	}

	var m map[IssueType][]*github.Issue

	// 分类
	for _, item := range result.Items {
		t := makeType(item.CreatedAt)
		m[t] = append(m[t], item)
	}

	fmt.Printf("%d issues:\n", result.TotalCount)
	for t, times := range m {
		println("issue type ", t)
		for _, item := range times {
			fmt.Printf("#%-5d %9.9s %.55s\n",
				item.Number, item.User.Login, item.Title)
		}
	}
}

0 replies

pyhita · 2025-06-21T12:49:49Z

pyhita
Jun 21, 2025 — with giscus

exercise 4.12

type XKCDComic struct {
	Month      string `json:"month"`      // 月份（字符串形式，如 "4"）
	Num        int    `json:"num"`        // 漫画编号（如 571）
	Link       string `json:"link"`       // 链接（示例中为空字符串）
	Year       string `json:"year"`       // 年份（字符串形式，如 "2009"）
	News       string `json:"news"`       // 新闻信息（示例中为空字符串）
	SafeTitle  string `json:"safe_title"` // 安全标题（不含特殊字符，如 "Can't Sleep"）
	Transcript string `json:"transcript"` // 漫画文本脚本（含多行和特殊符号）
	Alt        string `json:"alt"`        // 悬停提示文本（如关于 electric sheep 的提示）
	Img        string `json:"img"`        // 图片 URL（如 "https://imgs.xkcd.com/comics/cant_sleep.png"）
	Title      string `json:"title"`      // 完整标题（可能与 safe_title 相同）
	Day        string `json:"day"`        // 发布日期中的日（字符串形式，如 "20"）
	URL        string `json:"url"`        // 漫画的链接
}

const baseURL = "https://xkcd.com/"

// cache comic details
var details []*XKCDComic

func main() {
	start := flag.Int("start", 1, "search start index")
	end := flag.Int("end", 10, "search end index")
	search := flag.String("search", "", "search content")
	flag.Parse()

	// validate
	if *start > *end {
		fmt.Println("search start index is greater than end")
	}
	if *start <= 0 || *start > 1000 {
		fmt.Println("start must be between 0 and 1000")
	}
	if *end <= 0 || *end > 1000 {
		fmt.Println("end must be between 0 and 1000")
	}
	if *search == "" {
		fmt.Println("search is required")
	}

	buildLocalCache(*start, *end)
	searchComic(*search)
}

func buildLocalCache(start, end int) {
	var (
		wg      sync.WaitGroup
		results = make(chan *XKCDComic, end-start+1)
	)
	for i := start; i <= end; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			fmt.Printf("request %d comic\n", i)
			resp, err := http.Get(fmt.Sprintf("%s%d/info.0.json", baseURL, i))
			if err != nil {
				log.Printf("failed to fetch comic %d: %v", i, err)
				return
			}
			defer resp.Body.Close()

			b, err := io.ReadAll(resp.Body)
			if err != nil {
				log.Printf("failed to read comic %d: %v", i, err)
				return
			}

			var x XKCDComic
			if err := json.Unmarshal(b, &x); err != nil {
				log.Printf("failed to parse comic %d: %v", i, err)
				return
			}

			x.URL = fmt.Sprintf("%s%d", baseURL, i)
			results <- &x
		}(i)
	}

	wg.Wait()
	close(results)

	for x := range results {
		details = append(details, x)
	}

	fmt.Printf("%d comics found\n", len(details))
}

func buildLocalCache2(start, end int) {
	var (
		wg      sync.WaitGroup
		mu      sync.Mutex
		results = make(chan *XKCDComic, end-start)
	)

	// 启动 goroutine 消费 results
	go func() {
		wg.Wait()
		close(results)
	}()

	for i := start; i <= end; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()

			resp, err := http.Get(fmt.Sprintf("%s%d/info.0.json", baseURL, id))
			if err != nil {
				log.Printf("failed to fetch comic %d: %v", id, err)
				return
			}
			defer resp.Body.Close()

			b, err := io.ReadAll(resp.Body)
			if err != nil {
				log.Printf("failed to read comic %d: %v", id, err)
				return
			}

			var x XKCDComic
			if err := json.Unmarshal(b, &x); err != nil {
				log.Printf("failed to parse comic %d: %v", id, err)
				return
			}

			x.URL = fmt.Sprintf("%s%d", baseURL, id)
			results <- &x
		}(i)
	}

	// 安全地收集结果
	for x := range results {
		mu.Lock()
		details = append(details, x)
		mu.Unlock()
	}

	fmt.Printf("%d comics found\n", len(details))
}

func searchComic(search string) {
	var found *XKCDComic
	for _, x := range details {
		if strings.Contains(strings.ToLower(x.Title), strings.ToLower(search)) {
			found = x
			break
		}

		if strings.Contains(strings.ToLower(x.Transcript), strings.ToLower(search)) {
			found = x
			break
		}

		if strings.Contains(strings.ToLower(x.SafeTitle), strings.ToLower(search)) {
			found = x
			break
		}
	}

	if found == nil {
		fmt.Println("no comic found")
		return
	}

	fmt.Printf("comic found url: %s\n", found.URL)
}

0 replies

ch4/ch4-05 #158

Uh oh!

giscus[bot] bot Jan 11, 2023

ch4/ch4-05

Replies: 13 comments · 5 replies

Uh oh!

zhangbest5 Jan 11, 2023 — with giscus

Uh oh!

xianren68 Apr 25, 2023 — with giscus

4.10

github.go

main.go

Uh oh!

lyb88999 Apr 2, 2024 — with giscus

Uh oh!

xianren68 Apr 2, 2024

Uh oh!

lyb88999 Apr 3, 2024 — with giscus

Uh oh!

xianren68 Apr 3, 2024

Uh oh!

xianren68 Apr 26, 2023 — with giscus

4.12

test.go

main.go

Uh oh!

zhaojundu123 Jun 25, 2023 — with giscus

Uh oh!

zhaojundu123 Jun 25, 2023 — with giscus

Uh oh!

SuperZ3 Nov 1, 2023 — with giscus

Uh oh!

lyb88999 Apr 3, 2024 — with giscus

4.13

Uh oh!

hongjiala Mar 7, 2025 — with giscus

Uh oh!

hongjiala Mar 7, 2025 — with giscus

Uh oh!

hongjiala Mar 7, 2025 — with giscus

Uh oh!

hongjiala Mar 7, 2025 — with giscus

Uh oh!

celiachu Apr 2, 2025 — with giscus

4.12

Uh oh!

pyhita Jun 21, 2025 — with giscus

Uh oh!

pyhita Jun 21, 2025 — with giscus

giscus[bot]
bot Jan 11, 2023

Replies: 13 comments 5 replies

zhangbest5
Jan 11, 2023 — with giscus

xianren68
Apr 25, 2023 — with giscus

xianren68
Apr 26, 2023 — with giscus

zhaojundu123
Jun 25, 2023 — with giscus

SuperZ3
Nov 1, 2023 — with giscus

lyb88999
Apr 3, 2024 — with giscus

hongjiala
Mar 7, 2025 — with giscus

hongjiala
Mar 7, 2025 — with giscus

hongjiala
Mar 7, 2025 — with giscus

hongjiala
Mar 7, 2025 — with giscus

celiachu
Apr 2, 2025 — with giscus

pyhita
Jun 21, 2025 — with giscus

pyhita
Jun 21, 2025 — with giscus