2017-01-20 01:58:46 -05:00
// Copyright 2017 The Gitea Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
2021-11-19 08:39:57 -05:00
package repo
2017-01-20 01:58:46 -05:00
import (
2021-09-23 11:45:36 -04:00
"context"
2017-01-20 01:58:46 -05:00
"fmt"
2021-11-16 13:18:25 -05:00
"net/url"
2017-01-20 01:58:46 -05:00
"path"
2021-09-19 07:49:59 -04:00
"code.gitea.io/gitea/models/db"
2017-01-20 01:58:46 -05:00
"code.gitea.io/gitea/modules/setting"
2020-08-18 00:23:45 -04:00
"code.gitea.io/gitea/modules/storage"
2019-08-15 10:46:21 -04:00
"code.gitea.io/gitea/modules/timeutil"
2017-01-20 01:58:46 -05:00
)
// Attachment represent a attachment of issue/comment/release.
type Attachment struct {
2017-04-19 22:31:31 -04:00
ID int64 ` xorm:"pk autoincr" `
UUID string ` xorm:"uuid UNIQUE" `
2021-09-08 11:19:30 -04:00
RepoID int64 ` xorm:"INDEX" ` // this should not be zero
IssueID int64 ` xorm:"INDEX" ` // maybe zero when creating
ReleaseID int64 ` xorm:"INDEX" ` // maybe zero when creating
2019-04-02 15:25:05 -04:00
UploaderID int64 ` xorm:"INDEX DEFAULT 0" ` // Notice: will be zero before this column added
2017-04-19 22:31:31 -04:00
CommentID int64
Name string
2019-08-15 10:46:21 -04:00
DownloadCount int64 ` xorm:"DEFAULT 0" `
Size int64 ` xorm:"DEFAULT 0" `
CreatedUnix timeutil . TimeStamp ` xorm:"created" `
2017-01-20 01:58:46 -05:00
}
2021-09-19 07:49:59 -04:00
func init ( ) {
db . RegisterModel ( new ( Attachment ) )
}
2017-04-19 22:31:31 -04:00
// IncreaseDownloadCount is update download count + 1
func ( a * Attachment ) IncreaseDownloadCount ( ) error {
// Update download count.
2021-09-23 11:45:36 -04:00
if _ , err := db . GetEngine ( db . DefaultContext ) . Exec ( "UPDATE `attachment` SET download_count=download_count+1 WHERE id=?" , a . ID ) ; err != nil {
2017-04-19 22:31:31 -04:00
return fmt . Errorf ( "increase attachment count: %v" , err )
}
return nil
}
2020-08-18 00:23:45 -04:00
// AttachmentRelativePath returns the relative path
func AttachmentRelativePath ( uuid string ) string {
return path . Join ( uuid [ 0 : 1 ] , uuid [ 1 : 2 ] , uuid )
2017-01-20 01:58:46 -05:00
}
2020-08-18 00:23:45 -04:00
// RelativePath returns the relative path of the attachment
func ( a * Attachment ) RelativePath ( ) string {
return AttachmentRelativePath ( a . UUID )
2017-01-20 01:58:46 -05:00
}
2018-03-05 20:22:16 -05:00
// DownloadURL returns the download url of the attached file
func ( a * Attachment ) DownloadURL ( ) string {
2021-11-16 13:18:25 -05:00
return setting . AppURL + "attachments/" + url . PathEscape ( a . UUID )
2018-03-05 20:22:16 -05:00
}
2021-11-19 08:39:57 -05:00
// _____ __ __ .__ __
// / _ \_/ |__/ |______ ____ | |__ _____ ____ _____/ |_
// / /_\ \ __\ __\__ \ _/ ___\| | \ / \_/ __ \ / \ __\
// / | \ | | | / __ \\ \___| Y \ Y Y \ ___/| | \ |
// \____|__ /__| |__| (____ /\___ >___| /__|_| /\___ >___| /__|
// \/ \/ \/ \/ \/ \/ \/
// ErrAttachmentNotExist represents a "AttachmentNotExist" kind of error.
type ErrAttachmentNotExist struct {
ID int64
UUID string
}
// IsErrAttachmentNotExist checks if an error is a ErrAttachmentNotExist.
func IsErrAttachmentNotExist ( err error ) bool {
_ , ok := err . ( ErrAttachmentNotExist )
return ok
}
func ( err ErrAttachmentNotExist ) Error ( ) string {
return fmt . Sprintf ( "attachment does not exist [id: %d, uuid: %s]" , err . ID , err . UUID )
}
2022-05-20 10:08:52 -04:00
// GetAttachmentByID returns attachment by given id
func GetAttachmentByID ( ctx context . Context , id int64 ) ( * Attachment , error ) {
2020-06-17 13:50:11 -04:00
attach := & Attachment { }
2022-05-20 10:08:52 -04:00
if has , err := db . GetEngine ( ctx ) . ID ( id ) . Get ( attach ) ; err != nil {
2018-03-05 20:22:16 -05:00
return nil , err
} else if ! has {
return nil , ErrAttachmentNotExist { ID : id , UUID : "" }
}
return attach , nil
}
2022-05-20 10:08:52 -04:00
// GetAttachmentByUUID returns attachment by given UUID.
func GetAttachmentByUUID ( ctx context . Context , uuid string ) ( * Attachment , error ) {
2020-06-17 13:50:11 -04:00
attach := & Attachment { }
2022-05-20 10:08:52 -04:00
has , err := db . GetEngine ( ctx ) . Where ( "uuid=?" , uuid ) . Get ( attach )
2017-01-20 01:58:46 -05:00
if err != nil {
return nil , err
} else if ! has {
return nil , ErrAttachmentNotExist { 0 , uuid }
}
return attach , nil
}
2019-12-10 19:01:52 -05:00
// GetAttachmentsByUUIDs returns attachment by given UUID list.
2021-09-23 11:45:36 -04:00
func GetAttachmentsByUUIDs ( ctx context . Context , uuids [ ] string ) ( [ ] * Attachment , error ) {
2017-01-20 01:58:46 -05:00
if len ( uuids ) == 0 {
return [ ] * Attachment { } , nil
}
// Silently drop invalid uuids.
attachments := make ( [ ] * Attachment , 0 , len ( uuids ) )
2022-05-20 10:08:52 -04:00
return attachments , db . GetEngine ( ctx ) . In ( "uuid" , uuids ) . Find ( & attachments )
2017-01-20 01:58:46 -05:00
}
2021-09-06 10:46:20 -04:00
// ExistAttachmentsByUUID returns true if attachment is exist by given UUID
func ExistAttachmentsByUUID ( uuid string ) ( bool , error ) {
2021-09-23 11:45:36 -04:00
return db . GetEngine ( db . DefaultContext ) . Where ( "`uuid`=?" , uuid ) . Exist ( new ( Attachment ) )
2021-09-06 10:46:20 -04:00
}
2022-05-20 10:08:52 -04:00
// GetAttachmentsByIssueID returns all attachments of an issue.
func GetAttachmentsByIssueID ( ctx context . Context , issueID int64 ) ( [ ] * Attachment , error ) {
2017-01-20 01:58:46 -05:00
attachments := make ( [ ] * Attachment , 0 , 10 )
2021-11-19 08:39:57 -05:00
return attachments , db . GetEngine ( ctx ) . Where ( "issue_id = ? AND comment_id = 0" , issueID ) . Find ( & attachments )
2017-01-20 01:58:46 -05:00
}
// GetAttachmentsByCommentID returns all attachments if comment by given ID.
2022-05-20 10:08:52 -04:00
func GetAttachmentsByCommentID ( ctx context . Context , commentID int64 ) ( [ ] * Attachment , error ) {
2017-01-20 01:58:46 -05:00
attachments := make ( [ ] * Attachment , 0 , 10 )
2021-11-19 08:39:57 -05:00
return attachments , db . GetEngine ( ctx ) . Where ( "comment_id=?" , commentID ) . Find ( & attachments )
2017-01-20 01:58:46 -05:00
}
2022-05-20 10:08:52 -04:00
// GetAttachmentByReleaseIDFileName returns attachment by given releaseId and fileName.
func GetAttachmentByReleaseIDFileName ( ctx context . Context , releaseID int64 , fileName string ) ( * Attachment , error ) {
2019-01-06 17:37:30 -05:00
attach := & Attachment { ReleaseID : releaseID , Name : fileName }
2022-05-20 10:08:52 -04:00
has , err := db . GetEngine ( ctx ) . Get ( attach )
2019-01-06 17:37:30 -05:00
if err != nil {
return nil , err
} else if ! has {
return nil , err
}
return attach , nil
}
2017-01-20 01:58:46 -05:00
// DeleteAttachment deletes the given attachment and optionally the associated file.
func DeleteAttachment ( a * Attachment , remove bool ) error {
2021-09-23 11:45:36 -04:00
_ , err := DeleteAttachments ( db . DefaultContext , [ ] * Attachment { a } , remove )
2017-01-20 01:58:46 -05:00
return err
}
// DeleteAttachments deletes the given attachments and optionally the associated files.
2021-09-23 11:45:36 -04:00
func DeleteAttachments ( ctx context . Context , attachments [ ] * Attachment , remove bool ) ( int , error ) {
2017-12-24 16:04:22 -05:00
if len ( attachments ) == 0 {
return 0 , nil
}
2021-03-14 14:52:12 -04:00
ids := make ( [ ] int64 , 0 , len ( attachments ) )
2017-12-24 16:04:22 -05:00
for _ , a := range attachments {
ids = append ( ids , a . ID )
}
2021-09-23 11:45:36 -04:00
cnt , err := db . GetEngine ( ctx ) . In ( "id" , ids ) . NoAutoCondition ( ) . Delete ( attachments [ 0 ] )
2017-12-24 16:04:22 -05:00
if err != nil {
return 0 , err
}
if remove {
for i , a := range attachments {
2020-08-18 00:23:45 -04:00
if err := storage . Attachments . Delete ( a . RelativePath ( ) ) ; err != nil {
2017-01-20 01:58:46 -05:00
return i , e rr
}
}
}
2017-12-24 16:04:22 -05:00
return int ( cnt ) , nil
2017-01-20 01:58:46 -05:00
}
// DeleteAttachmentsByIssue deletes all attachments associated with the given issue.
func DeleteAttachmentsByIssue ( issueID int64 , remove bool ) ( int , error ) {
2022-05-20 10:08:52 -04:00
attachments , err := GetAttachmentsByIssueID ( db . DefaultContext , issueID )
2017-01-20 01:58:46 -05:00
if err != nil {
return 0 , err
}
2021-09-23 11:45:36 -04:00
return DeleteAttachments ( db . DefaultContext , attachments , remove )
2017-01-20 01:58:46 -05:00
}
// DeleteAttachmentsByComment deletes all attachments associated with the given comment.
func DeleteAttachmentsByComment ( commentID int64 , remove bool ) ( int , error ) {
2022-05-20 10:08:52 -04:00
attachments , err := GetAttachmentsByCommentID ( db . DefaultContext , commentID )
2017-01-20 01:58:46 -05:00
if err != nil {
return 0 , err
}
2021-09-23 11:45:36 -04:00
return DeleteAttachments ( db . DefaultContext , attachments , remove )
2017-01-20 01:58:46 -05:00
}
2018-03-05 20:22:16 -05:00
2021-03-22 12:09:51 -04:00
// UpdateAttachmentByUUID Updates attachment via uuid
2021-09-23 11:45:36 -04:00
func UpdateAttachmentByUUID ( ctx context . Context , attach * Attachment , cols ... string ) error {
2021-03-22 12:09:51 -04:00
if attach . UUID == "" {
2021-09-23 11:45:36 -04:00
return fmt . Errorf ( "attachment uuid should be not blank" )
2021-03-22 12:09:51 -04:00
}
2021-09-23 11:45:36 -04:00
_ , err := db . GetEngine ( ctx ) . Where ( "uuid=?" , attach . UUID ) . Cols ( cols ... ) . Update ( attach )
2021-03-22 12:09:51 -04:00
return err
}
2022-05-20 10:08:52 -04:00
// UpdateAttachment updates the given attachment in database
func UpdateAttachment ( ctx context . Context , atta * Attachment ) error {
2022-01-20 12:46:10 -05:00
sess := db . GetEngine ( ctx ) . Cols ( "name" , "issue_id" , "release_id" , "comment_id" , "download_count" )
2018-03-05 20:22:16 -05:00
if atta . ID != 0 && atta . UUID == "" {
2021-11-19 08:39:57 -05:00
sess = sess . ID ( atta . ID )
2018-03-05 20:22:16 -05:00
} else {
// Use uuid only if id is not set and uuid is set
2021-11-19 08:39:57 -05:00
sess = sess . Where ( "uuid = ?" , atta . UUID )
2018-03-05 20:22:16 -05:00
}
2021-11-19 08:39:57 -05:00
_ , err := sess . Update ( atta )
2018-03-05 20:22:16 -05:00
return err
}
2019-09-30 12:10:00 -04:00
// DeleteAttachmentsByRelease deletes all attachments associated with the given release.
func DeleteAttachmentsByRelease ( releaseID int64 ) error {
2021-09-23 11:45:36 -04:00
_ , err := db . GetEngine ( db . DefaultContext ) . Where ( "release_id = ?" , releaseID ) . Delete ( & Attachment { } )
2019-09-30 12:10:00 -04:00
return err
}
2020-08-18 00:23:45 -04:00
// IterateAttachment iterates attachments; it should not be used when Gitea is servicing users.
func IterateAttachment ( f func ( attach * Attachment ) error ) error {
var start int
const batchSize = 100
for {
2021-03-14 14:52:12 -04:00
attachments := make ( [ ] * Attachment , 0 , batchSize )
2021-09-23 11:45:36 -04:00
if err := db . GetEngine ( db . DefaultContext ) . Limit ( batchSize , start ) . Find ( & attachments ) ; err != nil {
2020-08-18 00:23:45 -04:00
return err
}
if len ( attachments ) == 0 {
return nil
}
start += len ( attachments )
for _ , attach := range attachments {
if err := f ( attach ) ; err != nil {
return err
}
}
}
}
2021-09-14 15:41:40 -04:00
// CountOrphanedAttachments returns the number of bad attachments
func CountOrphanedAttachments ( ) ( int64 , error ) {
2021-09-23 11:45:36 -04:00
return db . GetEngine ( db . DefaultContext ) . Where ( "(issue_id > 0 and issue_id not in (select id from issue)) or (release_id > 0 and release_id not in (select id from `release`))" ) .
2021-09-14 15:41:40 -04:00
Count ( new ( Attachment ) )
}
// DeleteOrphanedAttachments delete all bad attachments
func DeleteOrphanedAttachments ( ) error {
2021-09-23 11:45:36 -04:00
_ , err := db . GetEngine ( db . DefaultContext ) . Where ( "(issue_id > 0 and issue_id not in (select id from issue)) or (release_id > 0 and release_id not in (select id from `release`))" ) .
2021-09-14 15:41:40 -04:00
Delete ( new ( Attachment ) )
return err
}