package comic_center import ( "gorm.io/driver/sqlite" "gorm.io/gorm" "gorm.io/gorm/clause" "path" "pikapika/main/utils" "sync" "time" ) var mutex = sync.Mutex{} var db *gorm.DB func InitDBConnect(databaseDir string) { mutex.Lock() defer mutex.Unlock() var err error db, err = gorm.Open(sqlite.Open(path.Join(databaseDir, "comic_center.db")), utils.GormConfig) if err != nil { panic("failed to connect database") } db.AutoMigrate(&ComicView{}) db.AutoMigrate(&RemoteImage{}) db.AutoMigrate(&ComicDownload{}) db.AutoMigrate(&ComicDownloadEp{}) db.AutoMigrate(&ComicDownloadPicture{}) } func Transaction(t func(tx *gorm.DB) error) error { mutex.Lock() defer mutex.Unlock() return db.Transaction(t) } func NoLockActionViewComicUpdateInfoDB(view *ComicView, db *gorm.DB) error { view.LastViewTime = time.Now() return db.Clauses(clause.OnConflict{ Columns: []clause.Column{{Name: "id"}}, DoUpdates: clause.AssignmentColumns([]string{ "created_at", "updated_at", "title", "author", "pages_count", "eps_count", "finished", "categories", "thumb_original_name", "thumb_file_server", "thumb_path", "likes_count", "description", "chinese_team", "tags", "allow_download", "views_count", "is_favourite", "is_liked", "comments_count", "last_view_time", }), }).Create(view).Error } func ViewComicUpdateInfo(view *ComicView) error { mutex.Lock() defer mutex.Unlock() return NoLockActionViewComicUpdateInfoDB(view, db) } func ViewComic(comicId string) error { mutex.Lock() defer mutex.Unlock() return db.Model(&ComicView{}).Where( "id = ?", comicId, ).Update( "last_view_time", time.Now(), ).Error } func ViewComicUpdateFavourite(comicId string, favourite bool) error { mutex.Lock() defer mutex.Unlock() return db.Model(&ComicView{}).Where( "id = ?", comicId, ).Update( "is_favourite", favourite, ).Error } func ViewComicUpdateLike(comicId string, like bool) error { mutex.Lock() defer mutex.Unlock() return db.Model(&ComicView{}).Where( "id = ?", comicId, ).Update( "is_like", like, ).Error } func ViewEpAndPicture(comicId string, epOrder int, epTitle string, pictureRank int) error { mutex.Lock() defer mutex.Unlock() return db.Model(&ComicView{}).Where("id", comicId).Updates( map[string]interface{}{ "last_view_time": time.Now(), "last_view_ep_order": epOrder, "last_view_ep_title": epTitle, "last_view_picture_rank": pictureRank, }, ).Error } func LoadViewLog(comicId string) (*ComicView, error) { mutex.Lock() defer mutex.Unlock() var view ComicView err := db.First(&view, "id = ?", comicId).Error if err == gorm.ErrRecordNotFound { return nil, nil } if err != nil { return nil, err } return &view, nil } func FindRemoteImage(fileServer string, path string) *RemoteImage { mutex.Lock() defer mutex.Unlock() var remoteImage RemoteImage err := db.First(&remoteImage, "file_server = ? AND path = ?", fileServer, path).Error if err != nil { if err == gorm.ErrRecordNotFound { return nil } else { panic(err) } } return &remoteImage } func SaveRemoteImage(remote *RemoteImage) error { mutex.Lock() defer mutex.Unlock() return db.Clauses(clause.OnConflict{ Columns: []clause.Column{{Name: "file_server"}, {Name: "path"}}, DoUpdates: clause.AssignmentColumns([]string{ "updated_at", "file_size", "format", "width", "height", "local_path", }), }).Create(remote).Error } func CreateDownload(comic *ComicDownload, epList *[]ComicDownloadEp) error { mutex.Lock() defer mutex.Unlock() comic.SelectedEpCount = int32(len(*epList)) return db.Transaction(func(tx *gorm.DB) error { err := tx.Create(comic).Error if err != nil { return err } for _, ep := range *epList { err := tx.Create(&ep).Error if err != nil { return err } } return nil }) } func AddDownload(comic *ComicDownload, epList *[]ComicDownloadEp) error { mutex.Lock() defer mutex.Unlock() return db.Transaction(func(tx *gorm.DB) error { err := tx.Model(comic).Where("id = ?", comic.ID).Updates(map[string]interface{}{ "created_at": comic.CreatedAt, "updated_at": comic.UpdatedAt, "title": comic.Title, "author": comic.Author, "pages_count": comic.PagesCount, "eps_count": comic.EpsCount, "finished": comic.Finished, "categories": comic.Categories, "thumb_original_name": comic.ThumbOriginalName, "thumb_file_server": comic.ThumbFileServer, "thumb_path": comic.ThumbPath, "description": comic.Description, "chinese_team": comic.ChineseTeam, "tags": comic.Tags, "download_finished": false, // restart }).Error if err != nil { return err } err = tx.Exec( "UPDATE comic_downloads SET eps_count = selected_ep_count + ? WHERE id = ?", len(*epList), comic.ID, ).Error if err != nil { return err } for _, ep := range *epList { err := tx.Create(&ep).Error if err != nil { return err } } return nil }) } func UpdateDownloadLogo(comicId string, fileSize int64, format string, width int32, height int32, localPath string) error { mutex.Lock() defer mutex.Unlock() return db.Model(&ComicDownload{}).Where("id = ?", comicId).Updates(map[string]interface{}{ "thumb_file_size": fileSize, "thumb_format": format, "thumb_width": width, "thumb_height": height, "thumb_local_path": localPath, }).Error } func FindComicDownloadById(comicId string) (*ComicDownload, error) { mutex.Lock() defer mutex.Unlock() var download ComicDownload err := db.First(&download, "id = ?", comicId).Error if err != nil { if err == gorm.ErrRecordNotFound { return nil, nil } return nil, err } return &download, nil } func ListDownloadEpByComicId(comicId string) ([]ComicDownloadEp, error) { mutex.Lock() defer mutex.Unlock() var epList []ComicDownloadEp err := db.Where("comic_id = ?", comicId).Order("ep_order ASC").Find(&epList).Error return epList, err } func ListDownloadPictureByEpId(epId string) ([]ComicDownloadPicture, error) { mutex.Lock() defer mutex.Unlock() var pictureList []ComicDownloadPicture err := db.Where("ep_id = ?", epId).Order("rank_in_ep ASC").Find(&pictureList).Error return pictureList, err } func AllDownloads() (*[]ComicDownload, error) { mutex.Lock() defer mutex.Unlock() var downloads []ComicDownload err := db.Table("comic_downloads"). Joins("LEFT JOIN comic_views ON comic_views.id = comic_downloads.id"). Select("comic_downloads.*"). Order("comic_views.last_view_time DESC"). Scan(&downloads).Error // err := db.Find(&downloads).Error return &downloads, err } func LoadFirstNeedDownload() (*ComicDownload, error) { mutex.Lock() defer mutex.Unlock() var download ComicDownload err := db.First(&download, "download_failed = 0 AND pause = 0 AND deleting = 0 AND download_finished = 0").Error if err != nil { if err == gorm.ErrRecordNotFound { return nil, nil } return nil, err } return &download, nil } func LoadFirstNeedDownloadEp(comicId string) (*ComicDownloadEp, error) { mutex.Lock() defer mutex.Unlock() var ep ComicDownloadEp err := db.First( &ep, " comic_id = ? AND download_failed = 0 AND download_finished = 0 AND fetched_pictures = 1", comicId, ).Error if err != nil { if err == gorm.ErrRecordNotFound { return nil, nil } return nil, err } return &ep, nil } // LoadNeedDownloadPictures 根据EP.ID获取需要下载的图片 func LoadNeedDownloadPictures(epId string, limit int) (*[]ComicDownloadPicture, error) { mutex.Lock() defer mutex.Unlock() var pictures []ComicDownloadPicture err := db.Find( &pictures, "ep_id = ? AND download_failed = 0 AND download_finished = 0 LIMIT ?", epId, limit, ).Error return &pictures, err } func FetchPictures(comicId string, epId string, list *[]ComicDownloadPicture) error { mutex.Lock() defer mutex.Unlock() return db.Transaction(func(tx *gorm.DB) error { var rankInEp int32 for _, picture := range *list { rankInEp = rankInEp + 1 picture.RankInEp = rankInEp err := tx.Create(&picture).Error if err != nil { return err } } err := tx.Model(&ComicDownloadEp{}).Where("id = ?", epId).Updates(map[string]interface{}{ "fetched_pictures": true, "selected_picture_count": len(*list), }).Error if err != nil { return err } return tx.Exec( "UPDATE comic_downloads SET selected_picture_count = selected_picture_count + ? WHERE id = ?", len(*list), comicId, ).Error }) } func DownloadFailed(comicId string) error { mutex.Lock() defer mutex.Unlock() return db.Model(&ComicDownload{}).Where("id = ?", comicId).Update("download_failed", true).Error } func DownloadSuccess(comicId string) error { mutex.Lock() defer mutex.Unlock() return db.Model(&ComicDownload{}).Where("id = ?", comicId).Updates(map[string]interface{}{ "download_finished": true, "download_finished_time": time.Now(), }).Error } func EpFailed(epId string) error { mutex.Lock() defer mutex.Unlock() return db.Model(&ComicDownloadEp{}).Where("id = ?", epId).Update("download_failed", true).Error } func EpSuccess(comicId string, epId string) error { mutex.Lock() defer mutex.Unlock() return db.Transaction(func(tx *gorm.DB) error { err := tx.Model(&ComicDownloadEp{}).Where("id = ?", epId).Updates(map[string]interface{}{ "download_finished": true, "download_finished_time": time.Now(), }).Error if err != nil { return err } return tx.Exec( "UPDATE comic_downloads SET download_ep_count = download_ep_count + 1 WHERE id = ?", comicId, ).Error }) } func PictureFailed(pictureId string) error { mutex.Lock() defer mutex.Unlock() return db.Model(&ComicDownloadPicture{}).Where("id = ?", pictureId).Update("download_failed", true).Error } func PictureSuccess( comicId string, epId string, pictureId string, fileSize int64, format string, width int32, height int32, localPath string, ) error { mutex.Lock() defer mutex.Unlock() return db.Transaction(func(tx *gorm.DB) error { err := tx.Model(&ComicDownloadPicture{}).Where("id = ?", pictureId).Updates(map[string]interface{}{ "file_size": fileSize, "format": format, "width": width, "height": height, "local_path": localPath, "download_finished": true, "download_finished_time": time.Now(), }).Error if err != nil { return err } err = tx.Exec( "UPDATE comic_download_eps SET download_picture_count = download_picture_count + 1 WHERE id = ?", epId, ).Error if err != nil { return err } return tx.Exec( "UPDATE comic_downloads SET download_picture_count = download_picture_count + 1 WHERE id = ?", comicId, ).Error }) } func ResetAll() error { mutex.Lock() defer mutex.Unlock() return db.Transaction(func(tx *gorm.DB) error { err := tx.Model(&ComicDownload{}).Where("1 = 1"). Update("download_failed", false).Error if err != nil { return err } err = tx.Model(&ComicDownloadEp{}).Where("1 = 1"). Update("download_failed", false).Error if err != nil { return err } err = tx.Model(&ComicDownloadPicture{}).Where("1 = 1"). Update("download_failed", false).Error return err }) } func ViewLogPage(offset int, limit int) (*[]ComicView, error) { mutex.Lock() defer mutex.Unlock() var list []ComicView err := db.Offset(offset).Limit(limit).Order("last_view_time DESC").Find(&list).Error return &list, err } func ClearAllViewLog() { mutex.Lock() defer mutex.Unlock() db.Unscoped().Where("1 = 1").Delete(&ComicView{}) } func DeleteViewLog(id string) { mutex.Lock() defer mutex.Unlock() db.Unscoped().Where("id = ?", id).Delete(&ComicView{}) } func DeletingComic() (*ComicDownload, error) { mutex.Lock() defer mutex.Unlock() var download ComicDownload err := db.First(&download, "deleting = 1").Error if err == gorm.ErrRecordNotFound { return nil, nil } return &download, err } func TrueDelete(comicId string) error { mutex.Lock() defer mutex.Unlock() err := db.Transaction(func(tx *gorm.DB) error { err := tx.Unscoped().Delete(&ComicDownload{}, "id = ?", comicId).Error if err != nil { return err } err = tx.Unscoped().Delete(&ComicDownloadEp{}, "comic_id = ?", comicId).Error if err != nil { return err } err = tx.Unscoped().Delete(&ComicDownloadPicture{}, "comic_id = ?", comicId).Error if err != nil { return err } return nil }) if err != nil { return err } return db.Raw("VACUUM").Error } func Deleting(comicId string) error { mutex.Lock() defer mutex.Unlock() return db.Model(&ComicDownload{}).Where("id = ?", comicId).Updates(map[string]interface{}{ "deleting": true, }).Error } func RemoveAllRemoteImage() error { mutex.Lock() defer mutex.Unlock() err := db.Unscoped().Delete(&RemoteImage{}, "1 = 1").Error if err != nil { return err } return db.Raw("VACUUM").Error } func EarliestRemoteImage(earliest time.Time, pageSize int) ([]RemoteImage, error) { mutex.Lock() defer mutex.Unlock() var images []RemoteImage err := db.Where("strftime('%s',updated_at) < strftime('%s',?)", earliest). Order("updated_at").Limit(pageSize).Find(&images).Error return images, err } func DeleteRemoteImages(images []RemoteImage) error { mutex.Lock() defer mutex.Unlock() if len(images) == 0 { return nil } ids := make([]uint, len(images)) for i := 0; i < len(images); i++ { ids[i] = images[i].ID } return db.Unscoped().Model(&RemoteImage{}).Delete("id in ?", ids).Error } func DownloadInfo(comicId string) (*ComicDownload, error) { mutex.Lock() defer mutex.Unlock() var download ComicDownload err := db.First(&download, "id = ?", comicId).Error if err != nil { if err == gorm.ErrRecordNotFound { return nil, nil } return nil, err } return &download, nil } func VACUUM() error { mutex.Lock() defer mutex.Unlock() return db.Raw("VACUUM").Error }