🎨 改进代码结构

setutime/utils/download.go

@@ -8,8 +8,6 @@ import (
 	"net/http"
 	"os"
 	"strings"
-
-	zero "github.com/wdvxdr1123/ZeroBot"
 )
 
 // urlCache 缓存并返回缓存路径
@@ -26,7 +24,6 @@ func (this *Illust) PixivPicDown(path string) (savePath string, err error) {
 	if PathExists(savePath) && FileSize(savePath) > 10240 {
 		return savePath, nil
 	}
-	zero.SendGroupMessage(CACHE_GROUP, "正在下载"+url)
 	// TODO 模拟QQ客户端请求
 	client := &http.Client{}
 	reqest, _ := http.NewRequest("GET", url, nil)
@@ -51,6 +48,7 @@ func (this *Illust) PixivPicDown(path string) (savePath string, err error) {
 	return savePath, err
 }
 
+// PicHash 返回图片的 md5 值
 func PicHash(path string) string {
 	data, err := ioutil.ReadFile(path)
 	if err != nil {

setutime/utils/pic_pool.go

@@ -1,128 +1,78 @@
 package utils
 
 import (
-	"errors"
 	"fmt"
-	"strings"
 	"sync"
-
-	zero "github.com/wdvxdr1123/ZeroBot"
 )
 
-var (
-	CACHEPATH   string // 图片缓存路径
-	CACHE_GROUP int64  // 图片缓存群，用于上传图片到tx服务器
-)
-
-// PicsCache 图片缓冲池
-type PicsCache struct {
-	Lock     sync.Mutex
-	Max      int
-	ECY      []string
-	IECY     []Illust
-	SETU     []string
-	ISETU    []Illust
-	SCENERY  []string
-	ISCENERY []Illust
+// PoolsCache 图片缓冲池
+type PoolsCache struct {
+	Lock  sync.Mutex
+	Max   int
+	Path  string
+	Group int64
+	Pool  map[string][]*Illust
 }
 
-// Len 返回当前缓冲池的图片数量
-func (this *Illust) Len(type_ string, pool *PicsCache) (length int) {
-	switch type_ {
-	case "ecy":
-		return len(pool.ECY)
-	case "setu":
-		return len(pool.SETU)
-	case "scenery":
-		return len(pool.SCENERY)
+// NewPoolsCache 返回一个缓冲池对象
+func NewPoolsCache() *PoolsCache {
+	return &PoolsCache{
+		Max:   10,
+		Path:  "./data/SetuTime/cache/",
+		Group: 1048452984,
+		Pool:  map[string][]*Illust{},
 	}
-	return 0
 }
 
-// Add 添加图片到缓冲池，返回错误
-func (this Illust) Add(type_ string, pool *PicsCache) (err error) {
-	// TODO 下载图片
-	path, err := this.PixivPicDown(CACHEPATH)
-	if err != nil {
-		return err
-	}
-	hash := PicHash(path)
-	// TODO 发送到缓存群以上传tx服务器
-	if id := zero.SendGroupMessage(CACHE_GROUP, "[CQ:image,file=file:///"+path+"]"); id == 0 {
-		return errors.New("send failed")
-	}
-	// TODO 把hash和插图信息添加到缓冲池
-	pool.Lock.Lock()
-	defer pool.Lock.Unlock()
-	switch type_ {
-	case "ecy":
-		pool.ECY = append(pool.ECY, hash)
-		pool.IECY = append(pool.IECY, this)
-	case "setu":
-		pool.SETU = append(pool.SETU, hash)
-		pool.ISETU = append(pool.ISETU, this)
-	case "scenery":
-		pool.SCENERY = append(pool.SCENERY, hash)
-		pool.ISCENERY = append(pool.ISCENERY, this)
-	}
+// Size 返回缓冲池指定类型的现有大小
+func (p *PoolsCache) Size(type_ string) int {
+	return len(p.Pool[type_])
+}
+
+// IsFull 返回缓冲池指定类型是否已满
+func (p *PoolsCache) IsFull(type_ string) bool {
+	return len(p.Pool[type_]) >= p.Max
+}
+
+// Push 向缓冲池插入一张图片，返回错误
+func (p *PoolsCache) Push(type_ string, illust *Illust) (err error) {
+	p.Lock.Lock()
+	defer p.Lock.Unlock()
+	p.Pool[type_] = append(p.Pool[type_], illust)
 	return nil
 }
 
-// Get 从缓冲池里取出一张，返回hash，illust值中Pid和UserName会被改变
-func (this *Illust) Get(type_ string, pool *PicsCache) (hash string) {
-	pool.Lock.Lock()
-	defer pool.Lock.Unlock()
-	switch type_ {
-	case "ecy":
-		if len(pool.ECY) > 0 {
-			hash := pool.ECY[0]
-			this.Pid = pool.IECY[0].Pid
-			this.Title = pool.IECY[0].Title
-			this.UserName = pool.IECY[0].UserName
-			pool.ECY = pool.ECY[1:]
-			pool.IECY = pool.IECY[1:]
-			return hash
-		}
-	case "setu":
-		if len(pool.SETU) > 0 {
-			hash := pool.SETU[0]
-			this.Pid = pool.ISETU[0].Pid
-			this.Title = pool.ISETU[0].Title
-			this.UserName = pool.ISETU[0].UserName
-			pool.SETU = pool.SETU[1:]
-			pool.ISETU = pool.ISETU[1:]
-			return hash
-		}
-	case "scenery":
-		if len(pool.SCENERY) > 0 {
-			hash := pool.SCENERY[0]
-			this.Pid = pool.ISCENERY[0].Pid
-			this.Title = pool.ISCENERY[0].Title
-			this.UserName = pool.ISCENERY[0].UserName
-			pool.SCENERY = pool.SCENERY[1:]
-			pool.ISCENERY = pool.ISCENERY[1:]
-			return hash
-		}
-	default:
-		//
+// Push 在缓冲池拿出一张图片，返回错误
+func (p *PoolsCache) Pop(type_ string) (illust *Illust) {
+	p.Lock.Lock()
+	defer p.Lock.Unlock()
+	if p.Size(type_) == 0 {
+		return
 	}
-	return ""
+	illust = p.Pool[type_][0]
+	p.Pool[type_] = p.Pool[type_][1:]
+	return
 }
 
-func GetCQcodePicLink(text string) (url string) {
-	text = strings.ReplaceAll(text, "{", "")
-	text = strings.ReplaceAll(text, "{", "")
-	text = strings.ReplaceAll(text, "-", "")
-	if index := strings.Index(text, "."); index != -1 {
-		if hash := text[:index]; len(hash) == 32 {
-			return fmt.Sprintf("http://gchat.qpic.cn/gchatpic_new//--%s/0", hash)
-		}
+// Push 在缓冲池拿出一张图片，返回指定格式CQ码
+func (p *PoolsCache) GetOnePic(type_ string, form string) string {
+	var (
+		illust = p.Pop(type_)
+		file   = fmt.Sprintf("%s%d.jpg", p.Path, illust.Pid)
+	)
+	switch form {
+	case "XML":
+		return illust.BigPic(file)
+	case "DETAIL":
+		return illust.DetailPic(file)
+	default:
+		return illust.NormalPic(file)
 	}
-	return ""
 }
 
 // BigPic 返回一张XML大图CQ码
-func (this *Illust) BigPic(hash string) string {
+func (i *Illust) BigPic(file string) string {
+	var hash = PicHash(file)
 	return fmt.Sprintf(`[CQ:xml,data=<?xml version='1.0' 
 encoding='UTF-8' standalone='yes' ?><msg serviceID="5" 
 templateID="12345" action="" brief="不够涩！" 
@@ -135,29 +85,29 @@ action="" appid="-1" /></msg>]`,
 		hash,
 		hash,
 		hash,
-		this.Title,
-		this.Pid,
-		this.UserName,
+		i.Title,
+		i.Pid,
+		i.UserName,
 	)
 }
 
 // NormalPic 返回一张普通图CQ码
-func (this *Illust) NormalPic() string {
-	return fmt.Sprintf(`[CQ:image,file=file:///%s%d.jpg]`, CACHEPATH, this.Pid)
+func (i *Illust) NormalPic(file string) string {
+	return fmt.Sprintf(`[CQ:image,file=file:///%s]`, file)
 }
 
 // DetailPic 返回一张带详细信息的图片CQ码
-func (this *Illust) DetailPic() string {
+func (i *Illust) DetailPic(file string) string {
 	return fmt.Sprintf(`[SetuTime] %s 标题：%s 
 插画ID：%d 
 画师：%s 
 画师ID：%d 
 直链：https://pixivel.moe/detail?id=%d`,
-		this.NormalPic(),
-		this.Title,
-		this.Pid,
-		this.UserName,
-		this.UserId,
-		this.Pid,
+		i.NormalPic(file),
+		i.Title,
+		i.Pid,
+		i.UserName,
+		i.UserId,
+		i.Pid,
 	)
 }

setutime/utils/sqlite.go

@@ -3,19 +3,22 @@ package utils
 import (
 	"database/sql"
 	"errors"
-	"fmt"
 	"reflect"
+	"strings"
 
 	_ "github.com/mattn/go-sqlite3"
 )
 
+// Sqlite 数据库对象
 type Sqlite struct {
 	DB     *sql.DB
 	DBPath string
 }
 
-// DBCreate 根据结构体生成数据库table，tag为"id"为主键，自增
-func (db *Sqlite) DBCreate(objptr interface{}) (err error) {
+// Create 生成数据库
+// 默认结构体的第一个元素为主键
+// 返回错误
+func (db *Sqlite) Create(table string, objptr interface{}) (err error) {
 	if db.DB == nil {
 		database, err := sql.Open("sqlite3", db.DBPath)
 		if err != nil {
@@ -23,95 +26,127 @@ func (db *Sqlite) DBCreate(objptr interface{}) (err error) {
 		}
 		db.DB = database
 	}
-
-	table := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (", Struct2name(objptr))
-	for i, column := range strcut2columns(objptr) {
-		table += fmt.Sprintf(" %s %s NULL", column, column2type(objptr, column))
-		if i+1 != len(strcut2columns(objptr)) {
-			table += ","
-		} else {
-			table += " );"
+	var (
+		tags  = tags(objptr)
+		kinds = kinds(objptr)
+		top   = len(tags) - 1
+		cmd   = []string{}
+	)
+	cmd = append(cmd, "CREATE TABLE IF NOT EXISTS")
+	cmd = append(cmd, table)
+	cmd = append(cmd, "(")
+	for i := range tags {
+		cmd = append(cmd, tags[i])
+		cmd = append(cmd, kinds[i])
+		switch i {
+		default:
+			cmd = append(cmd, "NULL,")
+		case 0:
+			cmd = append(cmd, "PRIMARY KEY")
+			cmd = append(cmd, "NOT NULL,")
+		case top:
+			cmd = append(cmd, "NULL);")
 		}
 	}
-	if _, err := db.DB.Exec(table); err != nil {
+	if _, err := db.DB.Exec(strings.Join(cmd, " ")); err != nil {
 		return err
 	}
 	return nil
 }
 
-// DBInsert 根据结构体插入一条数据
-func (db *Sqlite) DBInsert(objptr interface{}) (err error) {
-	defer func() {
-		if err := recover(); err != nil {
-			panic(err)
-		}
-	}()
-	rows, err := db.DB.Query("SELECT * FROM " + Struct2name(objptr))
+// Insert 插入数据集
+// 默认结构体的第一个元素为主键
+// 返回错误
+func (db *Sqlite) Insert(table string, objptr interface{}) (err error) {
+	rows, err := db.DB.Query("SELECT * FROM " + table)
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
-
-	columns, _ := rows.Columns()
-	index := -1
-	names := "("
-	insert := "("
-	for i, column := range columns {
-		if column == "id" {
-			index = i
-			continue
-		}
-		if i != len(columns)-1 {
-			names += column + ","
-			insert += "?,"
-		} else {
-			names += column + ")"
-			insert += "?)"
+	tags, _ := rows.Columns()
+	var (
+		values = values(objptr)
+		top    = len(tags) - 1
+		cmd    = []string{}
+	)
+	cmd = append(cmd, "INSERT INTO")
+	cmd = append(cmd, table)
+	for i := range tags {
+		switch i {
+		default:
+			cmd = append(cmd, tags[i])
+			cmd = append(cmd, ",")
+		case 0:
+			cmd = append(cmd, "(")
+			cmd = append(cmd, tags[i])
+			cmd = append(cmd, ",")
+		case top:
+			cmd = append(cmd, tags[i])
+			cmd = append(cmd, ")")
 		}
 	}
-	stmt, err := db.DB.Prepare("INSERT INTO " + Struct2name(objptr) + names + " values " + insert)
+	for i := range tags {
+		switch i {
+		default:
+			cmd = append(cmd, "?")
+			cmd = append(cmd, ",")
+		case 0:
+			cmd = append(cmd, "VALUES (")
+			cmd = append(cmd, "?")
+			cmd = append(cmd, ",")
+		case top:
+			cmd = append(cmd, "?")
+			cmd = append(cmd, ")")
+		}
+	}
+	stmt, err := db.DB.Prepare(strings.Join(cmd, " "))
 	if err != nil {
 		return err
 	}
-
-	value := []interface{}{}
-	if index == -1 {
-		value = append(value, struct2values(objptr, columns)...)
-	} else {
-		value = append(value, append(struct2values(objptr, columns)[:index], struct2values(objptr, columns)[index+1:]...)...)
-	}
-	_, err = stmt.Exec(value...)
+	_, err = stmt.Exec(values...)
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
-// DBSelect 根据结构体查询对应的表，cmd可为"WHERE id = 0 "
-func (db *Sqlite) DBSelect(objptr interface{}, cmd string) (err error) {
-	rows, err := db.DB.Query(fmt.Sprintf("SELECT * FROM %s %s", Struct2name(objptr), cmd))
+// Select 查询数据库
+// condition 可为"WHERE id = 0"
+// 默认字段与结构体元素顺序一致
+// 返回错误
+func (db *Sqlite) Select(table string, objptr interface{}, condition string) (err error) {
+	var cmd = []string{}
+	cmd = append(cmd, "SELECT * FROM ")
+	cmd = append(cmd, table)
+	cmd = append(cmd, condition)
+	rows, err := db.DB.Query(strings.Join(cmd, " "))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 
 	for rows.Next() {
-		columns, err := rows.Columns()
 		if err != nil {
 			return err
 		}
-		err = rows.Scan(struct2addrs(objptr, columns)...)
+		err = rows.Scan(addrs(objptr)...)
 		if err != nil {
 			return err
 		}
 		return nil
 	}
-	return errors.New("Database no such elem")
+	return errors.New("数据库无此条件项目")
 }
 
-// DBDelete 删除struct对应表的一行，返回错误
-func (db *Sqlite) DBDelete(objptr interface{}, cmd string) (err error) {
-	stmt, err := db.DB.Prepare(fmt.Sprintf("DELETE FROM %s %s", Struct2name(objptr), cmd))
+// Delete 删除数据库
+// condition 可为"WHERE id = 0"
+// 返回错误
+func (db *Sqlite) Delete(table string, condition string) (err error) {
+	var cmd = []string{}
+	cmd = append(cmd, "DELETE FROM")
+	cmd = append(cmd, table)
+	cmd = append(cmd, condition)
+	stmt, err := db.DB.Prepare(strings.Join(cmd, " "))
 	if err != nil {
 		return err
 	}
@@ -122,9 +157,13 @@ func (db *Sqlite) DBDelete(objptr interface{}, cmd string) (err error) {
 	return nil
 }
 
-// DBNum 查询struct对应表的行数,返回行数以及错误
-func (db *Sqlite) DBNum(objptr interface{}) (num int, err error) {
-	rows, err := db.DB.Query(fmt.Sprintf("SELECT * FROM %s", Struct2name(objptr)))
+// Num 查询数据库行数
+// 返回行数以及错误
+func (db *Sqlite) Num(table string) (num int, err error) {
+	var cmd = []string{}
+	cmd = append(cmd, "SELECT * FROM")
+	cmd = append(cmd, table)
+	rows, err := db.DB.Query(strings.Join(cmd, " "))
 	if err != nil {
 		return num, err
 	}
@@ -135,90 +174,72 @@ func (db *Sqlite) DBNum(objptr interface{}) (num int, err error) {
 	return num, nil
 }
 
-// strcut2columns 反射得到结构体的 tag 数组
-func strcut2columns(objptr interface{}) []string {
-	var columns []string
+// tags 反射 返回结构体对象的 tag 数组
+func tags(objptr interface{}) []string {
+	var tags []string
 	elem := reflect.ValueOf(objptr).Elem()
 	// TODO 判断第一个元素是否为匿名字段
 	if elem.Type().Field(0).Anonymous {
 		elem = elem.Field(0)
 	}
 	for i, flen := 0, elem.Type().NumField(); i < flen; i++ {
-		columns = append(columns, elem.Type().Field(i).Tag.Get("db"))
+		tags = append(tags, elem.Type().Field(i).Tag.Get("db"))
 	}
-	return columns
+	return tags
 }
 
-// Struct2name 反射得到结构体的名字
-func Struct2name(objptr interface{}) string {
-	return reflect.ValueOf(objptr).Elem().Type().Name()
-}
-
-// column2type 反射得到结构体对应 tag 的 数据库数据类型
-func column2type(objptr interface{}, column string) string {
-	type_ := ""
+// kinds 反射 返回结构体对象的 kinds 数组
+func kinds(objptr interface{}) []string {
+	var kinds []string
 	elem := reflect.ValueOf(objptr).Elem()
 	// TODO 判断第一个元素是否为匿名字段
 	if elem.Type().Field(0).Anonymous {
 		elem = elem.Field(0)
 	}
 	for i, flen := 0, elem.Type().NumField(); i < flen; i++ {
-		if column == elem.Type().Field(i).Tag.Get("db") {
-			type_ = elem.Field(i).Type().String()
+		switch elem.Field(i).Type().String() {
+		case "int64":
+			kinds = append(kinds, "INT")
+		case "string":
+			kinds = append(kinds, "TEXT")
+		default:
+			kinds = append(kinds, "TEXT")
 		}
 	}
-	if column == "id" {
-		return "INTEGER PRIMARY KEY"
-	}
-	switch type_ {
-	case "int64":
-		return "INT"
-	case "string":
-		return "TEXT"
-	default:
-		return "TEXT"
-	}
+	return kinds
 }
 
-// struct2addrs 反射得到结构体对应数据库字段的属性地址
-func struct2addrs(objptr interface{}, columns []string) []interface{} {
-	var addrs []interface{}
-	elem := reflect.ValueOf(objptr).Elem()
-	// TODO 判断第一个元素是否为匿名字段
-	if elem.Type().Field(0).Anonymous {
-		elem = elem.Field(0)
-	}
-	for _, column := range columns {
-		for i, flen := 0, elem.Type().NumField(); i < flen; i++ {
-			if column == elem.Type().Field(i).Tag.Get("db") {
-				addrs = append(addrs, elem.Field(i).Addr().Interface())
-			}
-		}
-	}
-	return addrs
-}
-
-// struct2values 反射得到结构体对应数据库字段的属性值
-func struct2values(objptr interface{}, columns []string) []interface{} {
+// values 反射 返回结构体对象的 values 数组
+func values(objptr interface{}) []interface{} {
 	var values []interface{}
 	elem := reflect.ValueOf(objptr).Elem()
 	// TODO 判断第一个元素是否为匿名字段
 	if elem.Type().Field(0).Anonymous {
 		elem = elem.Field(0)
 	}
-	for _, column := range columns {
-		for i, flen := 0, elem.Type().NumField(); i < flen; i++ {
-			if column == elem.Type().Field(i).Tag.Get("db") {
-				switch elem.Field(i).Type().String() {
-				case "int64":
-					values = append(values, elem.Field(i).Int())
-				case "string":
-					values = append(values, elem.Field(i).String())
-				default:
-					values = append(values, elem.Field(i).String())
-				}
-			}
+	for i, flen := 0, elem.Type().NumField(); i < flen; i++ {
+		switch elem.Field(i).Type().String() {
+		case "int64":
+			values = append(values, elem.Field(i).Int())
+		case "string":
+			values = append(values, elem.Field(i).String())
+		default:
+			values = append(values, elem.Field(i).String())
 		}
 	}
 	return values
 }
+
+// addrs 反射 返回结构体对象的 addrs 数组
+func addrs(objptr interface{}) []interface{} {
+	var addrs []interface{}
+	elem := reflect.ValueOf(objptr).Elem()
+	// TODO 判断第一个元素是否为匿名字段
+	if elem.Type().Field(0).Anonymous {
+		elem = elem.Field(0)
+	}
+	for i, flen := 0, elem.Type().NumField(); i < flen; i++ {
+		addrs = append(addrs, elem.Field(i).Addr().Interface())
+	}
+	return addrs
+}

setutime/utils/utils.go

@@ -1,12 +1,9 @@
 package utils
 
 import (
-	"fmt"
 	"os"
 	"strconv"
 	"strings"
-
-	zero "github.com/wdvxdr1123/ZeroBot"
 )
 
 // Str2Int string --> int64
@@ -74,7 +71,3 @@ func Min(a, b int) int {
 		return a
 	}
 }
-
-func SendError(event zero.Event, err error) {
-	zero.Send(event, fmt.Sprintf("ERROR: %v", err))
-}