loading up the forgejo repo on tangled to test page performance
Merge pull request 'Implement external release assets' (#1445) from maltejur/forgejo:forgejo-external-attachments into forgejo
Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/1445
Reviewed-by: Earl Warren <earl-warren@noreply.codeberg.org>
+823
-116
+2
models/forgejo_migrations/migrate.go
+2
models/forgejo_migrations/migrate.go
···
74
74
NewMigration("Add `normalized_federated_uri` column to `user` table", AddNormalizedFederatedURIToUser),
75
75
// v18 -> v19
76
76
NewMigration("Create the `following_repo` table", CreateFollowingRepoTable),
77
+
// v19 -> v20
78
+
NewMigration("Add external_url to attachment table", AddExternalURLColumnToAttachmentTable),
77
79
}
78
80
79
81
// GetCurrentDBVersion returns the current Forgejo database version.
+14
models/forgejo_migrations/v19.go
+14
models/forgejo_migrations/v19.go
···
1
+
// Copyright 2024 The Forgejo Authors. All rights reserved.
2
+
// SPDX-License-Identifier: MIT
3
+
4
+
package forgejo_migrations //nolint:revive
5
+
6
+
import "xorm.io/xorm"
7
+
8
+
func AddExternalURLColumnToAttachmentTable(x *xorm.Engine) error {
9
+
type Attachment struct {
10
+
ID int64 `xorm:"pk autoincr"`
11
+
ExternalURL string
12
+
}
13
+
return x.Sync(new(Attachment))
14
+
}
+29
models/repo/attachment.go
+29
models/repo/attachment.go
···
14
14
"code.gitea.io/gitea/modules/storage"
15
15
"code.gitea.io/gitea/modules/timeutil"
16
16
"code.gitea.io/gitea/modules/util"
17
+
"code.gitea.io/gitea/modules/validation"
17
18
)
18
19
19
20
// Attachment represent a attachment of issue/comment/release.
···
31
32
NoAutoTime bool `xorm:"-"`
32
33
CreatedUnix timeutil.TimeStamp `xorm:"created"`
33
34
CustomDownloadURL string `xorm:"-"`
35
+
ExternalURL string
34
36
}
35
37
36
38
func init() {
···
59
61
60
62
// DownloadURL returns the download url of the attached file
61
63
func (a *Attachment) DownloadURL() string {
64
+
if a.ExternalURL != "" {
65
+
return a.ExternalURL
66
+
}
67
+
62
68
if a.CustomDownloadURL != "" {
63
69
return a.CustomDownloadURL
64
70
}
···
84
90
85
91
func (err ErrAttachmentNotExist) Unwrap() error {
86
92
return util.ErrNotExist
93
+
}
94
+
95
+
type ErrInvalidExternalURL struct {
96
+
ExternalURL string
97
+
}
98
+
99
+
func IsErrInvalidExternalURL(err error) bool {
100
+
_, ok := err.(ErrInvalidExternalURL)
101
+
return ok
102
+
}
103
+
104
+
func (err ErrInvalidExternalURL) Error() string {
105
+
return fmt.Sprintf("invalid external URL: '%s'", err.ExternalURL)
106
+
}
107
+
108
+
func (err ErrInvalidExternalURL) Unwrap() error {
109
+
return util.ErrPermissionDenied
87
110
}
88
111
89
112
// GetAttachmentByID returns attachment by given id
···
221
244
if attach.UUID == "" {
222
245
return fmt.Errorf("attachment uuid should be not blank")
223
246
}
247
+
if attach.ExternalURL != "" && !validation.IsValidExternalURL(attach.ExternalURL) {
248
+
return ErrInvalidExternalURL{ExternalURL: attach.ExternalURL}
249
+
}
224
250
_, err := db.GetEngine(ctx).Where("uuid=?", attach.UUID).Cols(cols...).Update(attach)
225
251
return err
226
252
}
227
253
228
254
// UpdateAttachment updates the given attachment in database
229
255
func UpdateAttachment(ctx context.Context, atta *Attachment) error {
256
+
if atta.ExternalURL != "" && !validation.IsValidExternalURL(atta.ExternalURL) {
257
+
return ErrInvalidExternalURL{ExternalURL: atta.ExternalURL}
258
+
}
230
259
sess := db.GetEngine(ctx).Cols("name", "issue_id", "release_id", "comment_id", "download_count")
231
260
if atta.ID != 0 && atta.UUID == "" {
232
261
sess = sess.ID(atta.ID)
+4
modules/structs/attachment.go
+4
modules/structs/attachment.go
···
18
18
Created time.Time `json:"created_at"`
19
19
UUID string `json:"uuid"`
20
20
DownloadURL string `json:"browser_download_url"`
21
+
// Enum: attachment,external
22
+
Type string `json:"type"`
21
23
}
22
24
23
25
// EditAttachmentOptions options for editing attachments
24
26
// swagger:model
25
27
type EditAttachmentOptions struct {
26
28
Name string `json:"name"`
29
+
// (Can only be set if existing attachment is of external type)
30
+
DownloadURL string `json:"browser_download_url"`
27
31
}
+6
options/locale/locale_en-US.ini
+6
options/locale/locale_en-US.ini
···
2721
2721
release.releases_for = Releases for %s
2722
2722
release.tags_for = Tags for %s
2723
2723
release.system_generated = This attachment is automatically generated.
2724
+
release.type_attachment = Attachment
2725
+
release.type_external_asset = External Asset
2726
+
release.asset_name = Asset Name
2727
+
release.asset_external_url = External URL
2728
+
release.add_external_asset = Add External Asset
2729
+
release.invalid_external_url = Invalid External URL: "%s"
2724
2730
2725
2731
branch.name = Branch name
2726
2732
branch.already_exists = A branch named "%s" already exists.
+3
-3
routers/api/v1/repo/release.go
+3
-3
routers/api/v1/repo/release.go
···
247
247
IsTag: false,
248
248
Repo: ctx.Repo.Repository,
249
249
}
250
-
if err := release_service.CreateRelease(ctx.Repo.GitRepo, rel, nil, ""); err != nil {
250
+
if err := release_service.CreateRelease(ctx.Repo.GitRepo, rel, "", nil); err != nil {
251
251
if repo_model.IsErrReleaseAlreadyExist(err) {
252
252
ctx.Error(http.StatusConflict, "ReleaseAlreadyExist", err)
253
253
} else if models.IsErrProtectedTagName(err) {
···
274
274
rel.Publisher = ctx.Doer
275
275
rel.Target = form.Target
276
276
277
-
if err = release_service.UpdateRelease(ctx, ctx.Doer, ctx.Repo.GitRepo, rel, nil, nil, nil, true); err != nil {
277
+
if err = release_service.UpdateRelease(ctx, ctx.Doer, ctx.Repo.GitRepo, rel, true, nil); err != nil {
278
278
ctx.Error(http.StatusInternalServerError, "UpdateRelease", err)
279
279
return
280
280
}
···
351
351
if form.HideArchiveLinks != nil {
352
352
rel.HideArchiveLinks = *form.HideArchiveLinks
353
353
}
354
-
if err := release_service.UpdateRelease(ctx, ctx.Doer, ctx.Repo.GitRepo, rel, nil, nil, nil, false); err != nil {
354
+
if err := release_service.UpdateRelease(ctx, ctx.Doer, ctx.Repo.GitRepo, rel, false, nil); err != nil {
355
355
ctx.Error(http.StatusInternalServerError, "UpdateRelease", err)
356
356
return
357
357
}
+104
-36
routers/api/v1/repo/release_attachment.go
+104
-36
routers/api/v1/repo/release_attachment.go
···
5
5
6
6
import (
7
7
"io"
8
+
"mime/multipart"
8
9
"net/http"
10
+
"net/url"
11
+
"path"
9
12
"strings"
10
13
11
14
repo_model "code.gitea.io/gitea/models/repo"
···
179
182
// description: name of the attachment
180
183
// type: string
181
184
// required: false
185
+
// # There is no good way to specify "either 'attachment' or 'external_url' is required" with OpenAPI
186
+
// # https://github.com/OAI/OpenAPI-Specification/issues/256
182
187
// - name: attachment
183
188
// in: formData
184
-
// description: attachment to upload
189
+
// description: attachment to upload (this parameter is incompatible with `external_url`)
185
190
// type: file
191
+
// required: false
192
+
// - name: external_url
193
+
// in: formData
194
+
// description: url to external asset (this parameter is incompatible with `attachment`)
195
+
// type: string
186
196
// required: false
187
197
// responses:
188
198
// "201":
···
205
215
}
206
216
207
217
// Get uploaded file from request
208
-
var content io.ReadCloser
209
-
var filename string
210
-
var size int64 = -1
218
+
var isForm, hasAttachmentFile, hasExternalURL bool
219
+
externalURL := ctx.FormString("external_url")
220
+
hasExternalURL = externalURL != ""
221
+
filename := ctx.FormString("name")
222
+
isForm = strings.HasPrefix(strings.ToLower(ctx.Req.Header.Get("Content-Type")), "multipart/form-data")
223
+
224
+
if isForm {
225
+
_, _, err := ctx.Req.FormFile("attachment")
226
+
hasAttachmentFile = err == nil
227
+
} else {
228
+
hasAttachmentFile = ctx.Req.Body != nil
229
+
}
230
+
231
+
if hasAttachmentFile && hasExternalURL {
232
+
ctx.Error(http.StatusBadRequest, "DuplicateAttachment", "'attachment' and 'external_url' are mutually exclusive")
233
+
} else if hasAttachmentFile {
234
+
var content io.ReadCloser
235
+
var size int64 = -1
236
+
237
+
if isForm {
238
+
var header *multipart.FileHeader
239
+
content, header, _ = ctx.Req.FormFile("attachment")
240
+
size = header.Size
241
+
defer content.Close()
242
+
if filename == "" {
243
+
filename = header.Filename
244
+
}
245
+
} else {
246
+
content = ctx.Req.Body
247
+
defer content.Close()
248
+
}
249
+
250
+
if filename == "" {
251
+
ctx.Error(http.StatusBadRequest, "MissingName", "Missing 'name' parameter")
252
+
return
253
+
}
211
254
212
-
if strings.HasPrefix(strings.ToLower(ctx.Req.Header.Get("Content-Type")), "multipart/form-data") {
213
-
file, header, err := ctx.Req.FormFile("attachment")
255
+
// Create a new attachment and save the file
256
+
attach, err := attachment.UploadAttachment(ctx, content, setting.Repository.Release.AllowedTypes, size, &repo_model.Attachment{
257
+
Name: filename,
258
+
UploaderID: ctx.Doer.ID,
259
+
RepoID: ctx.Repo.Repository.ID,
260
+
ReleaseID: releaseID,
261
+
})
214
262
if err != nil {
215
-
ctx.Error(http.StatusInternalServerError, "GetFile", err)
263
+
if upload.IsErrFileTypeForbidden(err) {
264
+
ctx.Error(http.StatusBadRequest, "DetectContentType", err)
265
+
return
266
+
}
267
+
ctx.Error(http.StatusInternalServerError, "NewAttachment", err)
216
268
return
217
269
}
218
-
defer file.Close()
219
270
220
-
content = file
221
-
size = header.Size
222
-
filename = header.Filename
223
-
if name := ctx.FormString("name"); name != "" {
224
-
filename = name
271
+
ctx.JSON(http.StatusCreated, convert.ToAPIAttachment(ctx.Repo.Repository, attach))
272
+
} else if hasExternalURL {
273
+
url, err := url.Parse(externalURL)
274
+
if err != nil {
275
+
ctx.Error(http.StatusBadRequest, "InvalidExternalURL", err)
276
+
return
225
277
}
226
-
} else {
227
-
content = ctx.Req.Body
228
-
filename = ctx.FormString("name")
229
-
}
230
278
231
-
if filename == "" {
232
-
ctx.Error(http.StatusBadRequest, "CreateReleaseAttachment", "Could not determine name of attachment.")
233
-
return
234
-
}
279
+
if filename == "" {
280
+
filename = path.Base(url.Path)
235
281
236
-
// Create a new attachment and save the file
237
-
attach, err := attachment.UploadAttachment(ctx, content, setting.Repository.Release.AllowedTypes, size, &repo_model.Attachment{
238
-
Name: filename,
239
-
UploaderID: ctx.Doer.ID,
240
-
RepoID: ctx.Repo.Repository.ID,
241
-
ReleaseID: releaseID,
242
-
})
243
-
if err != nil {
244
-
if upload.IsErrFileTypeForbidden(err) {
245
-
ctx.Error(http.StatusBadRequest, "DetectContentType", err)
282
+
if filename == "." {
283
+
// Url path is empty
284
+
filename = url.Host
285
+
}
286
+
}
287
+
288
+
attach, err := attachment.NewExternalAttachment(ctx, &repo_model.Attachment{
289
+
Name: filename,
290
+
UploaderID: ctx.Doer.ID,
291
+
RepoID: ctx.Repo.Repository.ID,
292
+
ReleaseID: releaseID,
293
+
ExternalURL: url.String(),
294
+
})
295
+
if err != nil {
296
+
if repo_model.IsErrInvalidExternalURL(err) {
297
+
ctx.Error(http.StatusBadRequest, "NewExternalAttachment", err)
298
+
} else {
299
+
ctx.Error(http.StatusInternalServerError, "NewExternalAttachment", err)
300
+
}
246
301
return
247
302
}
248
-
ctx.Error(http.StatusInternalServerError, "NewAttachment", err)
249
-
return
303
+
304
+
ctx.JSON(http.StatusCreated, convert.ToAPIAttachment(ctx.Repo.Repository, attach))
305
+
} else {
306
+
ctx.Error(http.StatusBadRequest, "MissingAttachment", "One of 'attachment' or 'external_url' is required")
250
307
}
251
-
252
-
ctx.JSON(http.StatusCreated, convert.ToAPIAttachment(ctx.Repo.Repository, attach))
253
308
}
254
309
255
310
// EditReleaseAttachment updates the given attachment
···
322
377
attach.Name = form.Name
323
378
}
324
379
380
+
if form.DownloadURL != "" {
381
+
if attach.ExternalURL == "" {
382
+
ctx.Error(http.StatusBadRequest, "EditAttachment", "existing attachment is not external")
383
+
return
384
+
}
385
+
attach.ExternalURL = form.DownloadURL
386
+
}
387
+
325
388
if err := repo_model.UpdateAttachment(ctx, attach); err != nil {
326
-
ctx.Error(http.StatusInternalServerError, "UpdateAttachment", attach)
389
+
if repo_model.IsErrInvalidExternalURL(err) {
390
+
ctx.Error(http.StatusBadRequest, "UpdateAttachment", err)
391
+
} else {
392
+
ctx.Error(http.StatusInternalServerError, "UpdateAttachment", err)
393
+
}
394
+
return
327
395
}
328
396
ctx.JSON(http.StatusCreated, convert.ToAPIAttachment(ctx.Repo.Repository, attach))
329
397
}
+5
routers/web/repo/attachment.go
+5
routers/web/repo/attachment.go
+122
-14
routers/web/repo/release.go
+122
-14
routers/web/repo/release.go
···
18
18
"code.gitea.io/gitea/models/unit"
19
19
user_model "code.gitea.io/gitea/models/user"
20
20
"code.gitea.io/gitea/modules/base"
21
+
"code.gitea.io/gitea/modules/container"
21
22
"code.gitea.io/gitea/modules/git"
22
23
"code.gitea.io/gitea/modules/gitrepo"
23
24
"code.gitea.io/gitea/modules/log"
···
491
492
return
492
493
}
493
494
494
-
var attachmentUUIDs []string
495
+
attachmentChanges := make(container.Set[*releaseservice.AttachmentChange])
496
+
attachmentChangesByID := make(map[string]*releaseservice.AttachmentChange)
497
+
495
498
if setting.Attachment.Enabled {
496
-
attachmentUUIDs = form.Files
499
+
for _, uuid := range form.Files {
500
+
attachmentChanges.Add(&releaseservice.AttachmentChange{
501
+
Action: "add",
502
+
Type: "attachment",
503
+
UUID: uuid,
504
+
})
505
+
}
506
+
507
+
const namePrefix = "attachment-new-name-"
508
+
const exturlPrefix = "attachment-new-exturl-"
509
+
for k, v := range ctx.Req.Form {
510
+
isNewName := strings.HasPrefix(k, namePrefix)
511
+
isNewExturl := strings.HasPrefix(k, exturlPrefix)
512
+
if isNewName || isNewExturl {
513
+
var id string
514
+
if isNewName {
515
+
id = k[len(namePrefix):]
516
+
} else if isNewExturl {
517
+
id = k[len(exturlPrefix):]
518
+
}
519
+
if _, ok := attachmentChangesByID[id]; !ok {
520
+
attachmentChangesByID[id] = &releaseservice.AttachmentChange{
521
+
Action: "add",
522
+
Type: "external",
523
+
}
524
+
attachmentChanges.Add(attachmentChangesByID[id])
525
+
}
526
+
if isNewName {
527
+
attachmentChangesByID[id].Name = v[0]
528
+
} else if isNewExturl {
529
+
attachmentChangesByID[id].ExternalURL = v[0]
530
+
}
531
+
}
532
+
}
497
533
}
498
534
499
535
rel, err := repo_model.GetRelease(ctx, ctx.Repo.Repository.ID, form.TagName)
···
553
589
IsTag: false,
554
590
}
555
591
556
-
if err = releaseservice.CreateRelease(ctx.Repo.GitRepo, rel, attachmentUUIDs, msg); err != nil {
592
+
if err = releaseservice.CreateRelease(ctx.Repo.GitRepo, rel, msg, attachmentChanges.Values()); err != nil {
557
593
ctx.Data["Err_TagName"] = true
558
594
switch {
559
595
case repo_model.IsErrReleaseAlreadyExist(err):
···
562
598
ctx.RenderWithErr(ctx.Tr("repo.release.tag_name_invalid"), tplReleaseNew, &form)
563
599
case models.IsErrProtectedTagName(err):
564
600
ctx.RenderWithErr(ctx.Tr("repo.release.tag_name_protected"), tplReleaseNew, &form)
601
+
case repo_model.IsErrInvalidExternalURL(err):
602
+
ctx.RenderWithErr(ctx.Tr("repo.release.invalid_external_url", err.(repo_model.ErrInvalidExternalURL).ExternalURL), tplReleaseNew, &form)
565
603
default:
566
604
ctx.ServerError("CreateRelease", err)
567
605
}
···
583
621
rel.HideArchiveLinks = form.HideArchiveLinks
584
622
rel.IsTag = false
585
623
586
-
if err = releaseservice.UpdateRelease(ctx, ctx.Doer, ctx.Repo.GitRepo, rel, attachmentUUIDs, nil, nil, true); err != nil {
624
+
if err = releaseservice.UpdateRelease(ctx, ctx.Doer, ctx.Repo.GitRepo, rel, true, attachmentChanges.Values()); err != nil {
587
625
ctx.Data["Err_TagName"] = true
588
-
ctx.ServerError("UpdateRelease", err)
626
+
switch {
627
+
case repo_model.IsErrInvalidExternalURL(err):
628
+
ctx.RenderWithErr(ctx.Tr("repo.release.invalid_external_url", err.(repo_model.ErrInvalidExternalURL).ExternalURL), tplReleaseNew, &form)
629
+
default:
630
+
ctx.ServerError("UpdateRelease", err)
631
+
}
589
632
return
590
633
}
591
634
}
···
667
710
ctx.Data["prerelease"] = rel.IsPrerelease
668
711
ctx.Data["hide_archive_links"] = rel.HideArchiveLinks
669
712
713
+
rel.Repo = ctx.Repo.Repository
714
+
if err := rel.LoadAttributes(ctx); err != nil {
715
+
ctx.ServerError("LoadAttributes", err)
716
+
return
717
+
}
718
+
// TODO: If an error occurs, do not forget the attachment edits the user made
719
+
// when displaying the error message.
720
+
ctx.Data["attachments"] = rel.Attachments
721
+
670
722
if ctx.HasError() {
671
723
ctx.HTML(http.StatusOK, tplReleaseNew)
672
724
return
···
674
726
675
727
const delPrefix = "attachment-del-"
676
728
const editPrefix = "attachment-edit-"
677
-
var addAttachmentUUIDs, delAttachmentUUIDs []string
678
-
editAttachments := make(map[string]string) // uuid -> new name
729
+
const newPrefix = "attachment-new-"
730
+
const namePrefix = "name-"
731
+
const exturlPrefix = "exturl-"
732
+
attachmentChanges := make(container.Set[*releaseservice.AttachmentChange])
733
+
attachmentChangesByID := make(map[string]*releaseservice.AttachmentChange)
734
+
679
735
if setting.Attachment.Enabled {
680
-
addAttachmentUUIDs = form.Files
736
+
for _, uuid := range form.Files {
737
+
attachmentChanges.Add(&releaseservice.AttachmentChange{
738
+
Action: "add",
739
+
Type: "attachment",
740
+
UUID: uuid,
741
+
})
742
+
}
743
+
681
744
for k, v := range ctx.Req.Form {
682
745
if strings.HasPrefix(k, delPrefix) && v[0] == "true" {
683
-
delAttachmentUUIDs = append(delAttachmentUUIDs, k[len(delPrefix):])
684
-
} else if strings.HasPrefix(k, editPrefix) {
685
-
editAttachments[k[len(editPrefix):]] = v[0]
746
+
attachmentChanges.Add(&releaseservice.AttachmentChange{
747
+
Action: "delete",
748
+
UUID: k[len(delPrefix):],
749
+
})
750
+
} else {
751
+
isUpdatedName := strings.HasPrefix(k, editPrefix+namePrefix)
752
+
isUpdatedExturl := strings.HasPrefix(k, editPrefix+exturlPrefix)
753
+
isNewName := strings.HasPrefix(k, newPrefix+namePrefix)
754
+
isNewExturl := strings.HasPrefix(k, newPrefix+exturlPrefix)
755
+
756
+
if isUpdatedName || isUpdatedExturl || isNewName || isNewExturl {
757
+
var uuid string
758
+
759
+
if isUpdatedName {
760
+
uuid = k[len(editPrefix+namePrefix):]
761
+
} else if isUpdatedExturl {
762
+
uuid = k[len(editPrefix+exturlPrefix):]
763
+
} else if isNewName {
764
+
uuid = k[len(newPrefix+namePrefix):]
765
+
} else if isNewExturl {
766
+
uuid = k[len(newPrefix+exturlPrefix):]
767
+
}
768
+
769
+
if _, ok := attachmentChangesByID[uuid]; !ok {
770
+
attachmentChangesByID[uuid] = &releaseservice.AttachmentChange{
771
+
Type: "attachment",
772
+
UUID: uuid,
773
+
}
774
+
attachmentChanges.Add(attachmentChangesByID[uuid])
775
+
}
776
+
777
+
if isUpdatedName || isUpdatedExturl {
778
+
attachmentChangesByID[uuid].Action = "update"
779
+
} else if isNewName || isNewExturl {
780
+
attachmentChangesByID[uuid].Action = "add"
781
+
}
782
+
783
+
if isUpdatedName || isNewName {
784
+
attachmentChangesByID[uuid].Name = v[0]
785
+
} else if isUpdatedExturl || isNewExturl {
786
+
attachmentChangesByID[uuid].ExternalURL = v[0]
787
+
attachmentChangesByID[uuid].Type = "external"
788
+
}
789
+
}
686
790
}
687
791
}
688
792
}
···
692
796
rel.IsDraft = len(form.Draft) > 0
693
797
rel.IsPrerelease = form.Prerelease
694
798
rel.HideArchiveLinks = form.HideArchiveLinks
695
-
if err = releaseservice.UpdateRelease(ctx, ctx.Doer, ctx.Repo.GitRepo,
696
-
rel, addAttachmentUUIDs, delAttachmentUUIDs, editAttachments, false); err != nil {
697
-
ctx.ServerError("UpdateRelease", err)
799
+
if err = releaseservice.UpdateRelease(ctx, ctx.Doer, ctx.Repo.GitRepo, rel, false, attachmentChanges.Values()); err != nil {
800
+
switch {
801
+
case repo_model.IsErrInvalidExternalURL(err):
802
+
ctx.RenderWithErr(ctx.Tr("repo.release.invalid_external_url", err.(repo_model.ErrInvalidExternalURL).ExternalURL), tplReleaseNew, &form)
803
+
default:
804
+
ctx.ServerError("UpdateRelease", err)
805
+
}
698
806
return
699
807
}
700
808
ctx.Redirect(ctx.Repo.RepoLink + "/releases")
+23
services/attachment/attachment.go
+23
services/attachment/attachment.go
···
13
13
repo_model "code.gitea.io/gitea/models/repo"
14
14
"code.gitea.io/gitea/modules/storage"
15
15
"code.gitea.io/gitea/modules/util"
16
+
"code.gitea.io/gitea/modules/validation"
16
17
"code.gitea.io/gitea/services/context/upload"
17
18
18
19
"github.com/google/uuid"
···
39
40
_, err = eng.Insert(attach)
40
41
return err
41
42
})
43
+
44
+
return attach, err
45
+
}
46
+
47
+
func NewExternalAttachment(ctx context.Context, attach *repo_model.Attachment) (*repo_model.Attachment, error) {
48
+
if attach.RepoID == 0 {
49
+
return nil, fmt.Errorf("attachment %s should belong to a repository", attach.Name)
50
+
}
51
+
if attach.ExternalURL == "" {
52
+
return nil, fmt.Errorf("attachment %s should have a external url", attach.Name)
53
+
}
54
+
if !validation.IsValidExternalURL(attach.ExternalURL) {
55
+
return nil, repo_model.ErrInvalidExternalURL{ExternalURL: attach.ExternalURL}
56
+
}
57
+
58
+
attach.UUID = uuid.New().String()
59
+
60
+
eng := db.GetEngine(ctx)
61
+
if attach.NoAutoTime {
62
+
eng.NoAutoTime()
63
+
}
64
+
_, err := eng.Insert(attach)
42
65
43
66
return attach, err
44
67
}
+11
services/convert/attachment.go
+11
services/convert/attachment.go
···
9
9
)
10
10
11
11
func WebAssetDownloadURL(repo *repo_model.Repository, attach *repo_model.Attachment) string {
12
+
if attach.ExternalURL != "" {
13
+
return attach.ExternalURL
14
+
}
15
+
12
16
return attach.DownloadURL()
13
17
}
14
18
···
28
32
29
33
// toAttachment converts models.Attachment to api.Attachment for API usage
30
34
func toAttachment(repo *repo_model.Repository, a *repo_model.Attachment, getDownloadURL func(repo *repo_model.Repository, attach *repo_model.Attachment) string) *api.Attachment {
35
+
var typeName string
36
+
if a.ExternalURL != "" {
37
+
typeName = "external"
38
+
} else {
39
+
typeName = "attachment"
40
+
}
31
41
return &api.Attachment{
32
42
ID: a.ID,
33
43
Name: a.Name,
···
36
46
Size: a.Size,
37
47
UUID: a.UUID,
38
48
DownloadURL: getDownloadURL(repo, a), // for web request json and api request json, return different download urls
49
+
Type: typeName,
39
50
}
40
51
}
41
52
+1
-1
services/f3/driver/release.go
+1
-1
services/f3/driver/release.go
···
129
129
panic(err)
130
130
}
131
131
defer gitRepo.Close()
132
-
if err := release_service.CreateRelease(gitRepo, o.forgejoRelease, nil, ""); err != nil {
132
+
if err := release_service.CreateRelease(gitRepo, o.forgejoRelease, "", nil); err != nil {
133
133
panic(err)
134
134
}
135
135
o.Trace("release created %d", o.forgejoRelease.ID)
+112
-22
services/release/release.go
+112
-22
services/release/release.go
···
23
23
"code.gitea.io/gitea/modules/storage"
24
24
"code.gitea.io/gitea/modules/timeutil"
25
25
"code.gitea.io/gitea/modules/util"
26
+
"code.gitea.io/gitea/services/attachment"
26
27
notify_service "code.gitea.io/gitea/services/notify"
27
28
)
29
+
30
+
type AttachmentChange struct {
31
+
Action string // "add", "delete", "update
32
+
Type string // "attachment", "external"
33
+
UUID string
34
+
Name string
35
+
ExternalURL string
36
+
}
28
37
29
38
func createTag(ctx context.Context, gitRepo *git.Repository, rel *repo_model.Release, msg string) (bool, error) {
30
39
err := rel.LoadAttributes(ctx)
···
128
137
}
129
138
130
139
// CreateRelease creates a new release of repository.
131
-
func CreateRelease(gitRepo *git.Repository, rel *repo_model.Release, attachmentUUIDs []string, msg string) error {
140
+
func CreateRelease(gitRepo *git.Repository, rel *repo_model.Release, msg string, attachmentChanges []*AttachmentChange) error {
132
141
has, err := repo_model.IsReleaseExist(gitRepo.Ctx, rel.RepoID, rel.TagName)
133
142
if err != nil {
134
143
return err
···
147
156
return err
148
157
}
149
158
150
-
if err = repo_model.AddReleaseAttachments(gitRepo.Ctx, rel.ID, attachmentUUIDs); err != nil {
159
+
addAttachmentUUIDs := make(container.Set[string])
160
+
161
+
for _, attachmentChange := range attachmentChanges {
162
+
if attachmentChange.Action != "add" {
163
+
return fmt.Errorf("can only create new attachments when creating release")
164
+
}
165
+
switch attachmentChange.Type {
166
+
case "attachment":
167
+
if attachmentChange.UUID == "" {
168
+
return fmt.Errorf("new attachment should have a uuid")
169
+
}
170
+
addAttachmentUUIDs.Add(attachmentChange.UUID)
171
+
case "external":
172
+
if attachmentChange.Name == "" || attachmentChange.ExternalURL == "" {
173
+
return fmt.Errorf("new external attachment should have a name and external url")
174
+
}
175
+
176
+
_, err = attachment.NewExternalAttachment(gitRepo.Ctx, &repo_model.Attachment{
177
+
Name: attachmentChange.Name,
178
+
UploaderID: rel.PublisherID,
179
+
RepoID: rel.RepoID,
180
+
ReleaseID: rel.ID,
181
+
ExternalURL: attachmentChange.ExternalURL,
182
+
})
183
+
if err != nil {
184
+
return err
185
+
}
186
+
default:
187
+
if attachmentChange.Type == "" {
188
+
return fmt.Errorf("missing attachment type")
189
+
}
190
+
return fmt.Errorf("unknown attachment type: '%q'", attachmentChange.Type)
191
+
}
192
+
}
193
+
194
+
if err = repo_model.AddReleaseAttachments(gitRepo.Ctx, rel.ID, addAttachmentUUIDs.Values()); err != nil {
151
195
return err
152
196
}
153
197
···
198
242
// addAttachmentUUIDs accept a slice of new created attachments' uuids which will be reassigned release_id as the created release
199
243
// delAttachmentUUIDs accept a slice of attachments' uuids which will be deleted from the release
200
244
// editAttachments accept a map of attachment uuid to new attachment name which will be updated with attachments.
201
-
func UpdateRelease(ctx context.Context, doer *user_model.User, gitRepo *git.Repository, rel *repo_model.Release,
202
-
addAttachmentUUIDs, delAttachmentUUIDs []string, editAttachments map[string]string, createdFromTag bool,
245
+
func UpdateRelease(ctx context.Context, doer *user_model.User, gitRepo *git.Repository, rel *repo_model.Release, createdFromTag bool, attachmentChanges []*AttachmentChange,
203
246
) error {
204
247
if rel.ID == 0 {
205
248
return errors.New("UpdateRelease only accepts an exist release")
···
220
263
return err
221
264
}
222
265
223
-
if err = repo_model.AddReleaseAttachments(ctx, rel.ID, addAttachmentUUIDs); err != nil {
266
+
addAttachmentUUIDs := make(container.Set[string])
267
+
delAttachmentUUIDs := make(container.Set[string])
268
+
updateAttachmentUUIDs := make(container.Set[string])
269
+
updateAttachments := make(container.Set[*AttachmentChange])
270
+
271
+
for _, attachmentChange := range attachmentChanges {
272
+
switch attachmentChange.Action {
273
+
case "add":
274
+
switch attachmentChange.Type {
275
+
case "attachment":
276
+
if attachmentChange.UUID == "" {
277
+
return fmt.Errorf("new attachment should have a uuid (%s)}", attachmentChange.Name)
278
+
}
279
+
addAttachmentUUIDs.Add(attachmentChange.UUID)
280
+
case "external":
281
+
if attachmentChange.Name == "" || attachmentChange.ExternalURL == "" {
282
+
return fmt.Errorf("new external attachment should have a name and external url")
283
+
}
284
+
_, err := attachment.NewExternalAttachment(ctx, &repo_model.Attachment{
285
+
Name: attachmentChange.Name,
286
+
UploaderID: doer.ID,
287
+
RepoID: rel.RepoID,
288
+
ReleaseID: rel.ID,
289
+
ExternalURL: attachmentChange.ExternalURL,
290
+
})
291
+
if err != nil {
292
+
return err
293
+
}
294
+
default:
295
+
if attachmentChange.Type == "" {
296
+
return fmt.Errorf("missing attachment type")
297
+
}
298
+
return fmt.Errorf("unknown attachment type: %q", attachmentChange.Type)
299
+
}
300
+
case "delete":
301
+
if attachmentChange.UUID == "" {
302
+
return fmt.Errorf("attachment deletion should have a uuid")
303
+
}
304
+
delAttachmentUUIDs.Add(attachmentChange.UUID)
305
+
case "update":
306
+
updateAttachmentUUIDs.Add(attachmentChange.UUID)
307
+
updateAttachments.Add(attachmentChange)
308
+
default:
309
+
if attachmentChange.Action == "" {
310
+
return fmt.Errorf("missing attachment action")
311
+
}
312
+
return fmt.Errorf("unknown attachment action: %q", attachmentChange.Action)
313
+
}
314
+
}
315
+
316
+
if err = repo_model.AddReleaseAttachments(ctx, rel.ID, addAttachmentUUIDs.Values()); err != nil {
224
317
return fmt.Errorf("AddReleaseAttachments: %w", err)
225
318
}
226
319
227
320
deletedUUIDs := make(container.Set[string])
228
321
if len(delAttachmentUUIDs) > 0 {
229
322
// Check attachments
230
-
attachments, err := repo_model.GetAttachmentsByUUIDs(ctx, delAttachmentUUIDs)
323
+
attachments, err := repo_model.GetAttachmentsByUUIDs(ctx, delAttachmentUUIDs.Values())
231
324
if err != nil {
232
325
return fmt.Errorf("GetAttachmentsByUUIDs [uuids: %v]: %w", delAttachmentUUIDs, err)
233
326
}
···
246
339
}
247
340
}
248
341
249
-
if len(editAttachments) > 0 {
250
-
updateAttachmentsList := make([]string, 0, len(editAttachments))
251
-
for k := range editAttachments {
252
-
updateAttachmentsList = append(updateAttachmentsList, k)
253
-
}
342
+
if len(updateAttachmentUUIDs) > 0 {
254
343
// Check attachments
255
-
attachments, err := repo_model.GetAttachmentsByUUIDs(ctx, updateAttachmentsList)
344
+
attachments, err := repo_model.GetAttachmentsByUUIDs(ctx, updateAttachmentUUIDs.Values())
256
345
if err != nil {
257
-
return fmt.Errorf("GetAttachmentsByUUIDs [uuids: %v]: %w", updateAttachmentsList, err)
346
+
return fmt.Errorf("GetAttachmentsByUUIDs [uuids: %v]: %w", updateAttachmentUUIDs, err)
258
347
}
259
348
for _, attach := range attachments {
260
349
if attach.ReleaseID != rel.ID {
···
264
353
}
265
354
}
266
355
}
356
+
}
267
357
268
-
for uuid, newName := range editAttachments {
269
-
if !deletedUUIDs.Contains(uuid) {
270
-
if err = repo_model.UpdateAttachmentByUUID(ctx, &repo_model.Attachment{
271
-
UUID: uuid,
272
-
Name: newName,
273
-
}, "name"); err != nil {
274
-
return err
275
-
}
358
+
for attachmentChange := range updateAttachments {
359
+
if !deletedUUIDs.Contains(attachmentChange.UUID) {
360
+
if err = repo_model.UpdateAttachmentByUUID(ctx, &repo_model.Attachment{
361
+
UUID: attachmentChange.UUID,
362
+
Name: attachmentChange.Name,
363
+
ExternalURL: attachmentChange.ExternalURL,
364
+
}, "name", "external_url"); err != nil {
365
+
return err
276
366
}
277
367
}
278
368
}
···
281
371
return err
282
372
}
283
373
284
-
for _, uuid := range delAttachmentUUIDs {
374
+
for _, uuid := range delAttachmentUUIDs.Values() {
285
375
if err := storage.Attachments.Delete(repo_model.AttachmentRelativePath(uuid)); err != nil {
286
376
// Even delete files failed, but the attachments has been removed from database, so we
287
377
// should not return error but only record the error on logs.
+129
-19
services/release/release_test.go
+129
-19
services/release/release_test.go
···
47
47
IsDraft: false,
48
48
IsPrerelease: false,
49
49
IsTag: false,
50
-
}, nil, ""))
50
+
}, "", []*AttachmentChange{}))
51
51
52
52
assert.NoError(t, CreateRelease(gitRepo, &repo_model.Release{
53
53
RepoID: repo.ID,
···
61
61
IsDraft: false,
62
62
IsPrerelease: false,
63
63
IsTag: false,
64
-
}, nil, ""))
64
+
}, "", []*AttachmentChange{}))
65
65
66
66
assert.NoError(t, CreateRelease(gitRepo, &repo_model.Release{
67
67
RepoID: repo.ID,
···
75
75
IsDraft: false,
76
76
IsPrerelease: false,
77
77
IsTag: false,
78
-
}, nil, ""))
78
+
}, "", []*AttachmentChange{}))
79
79
80
80
assert.NoError(t, CreateRelease(gitRepo, &repo_model.Release{
81
81
RepoID: repo.ID,
···
89
89
IsDraft: true,
90
90
IsPrerelease: false,
91
91
IsTag: false,
92
-
}, nil, ""))
92
+
}, "", []*AttachmentChange{}))
93
93
94
94
assert.NoError(t, CreateRelease(gitRepo, &repo_model.Release{
95
95
RepoID: repo.ID,
···
103
103
IsDraft: false,
104
104
IsPrerelease: true,
105
105
IsTag: false,
106
-
}, nil, ""))
106
+
}, "", []*AttachmentChange{}))
107
107
108
108
testPlayload := "testtest"
109
109
···
127
127
IsPrerelease: false,
128
128
IsTag: true,
129
129
}
130
-
assert.NoError(t, CreateRelease(gitRepo, &release, []string{attach.UUID}, "test"))
130
+
assert.NoError(t, CreateRelease(gitRepo, &release, "test", []*AttachmentChange{
131
+
{
132
+
Action: "add",
133
+
Type: "attachment",
134
+
UUID: attach.UUID,
135
+
},
136
+
}))
137
+
assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, &release))
138
+
assert.Len(t, release.Attachments, 1)
139
+
assert.EqualValues(t, attach.UUID, release.Attachments[0].UUID)
140
+
assert.EqualValues(t, attach.Name, release.Attachments[0].Name)
141
+
assert.EqualValues(t, attach.ExternalURL, release.Attachments[0].ExternalURL)
142
+
143
+
release = repo_model.Release{
144
+
RepoID: repo.ID,
145
+
Repo: repo,
146
+
PublisherID: user.ID,
147
+
Publisher: user,
148
+
TagName: "v0.1.6",
149
+
Target: "65f1bf2",
150
+
Title: "v0.1.6 is released",
151
+
Note: "v0.1.6 is released",
152
+
IsDraft: false,
153
+
IsPrerelease: false,
154
+
IsTag: true,
155
+
}
156
+
assert.NoError(t, CreateRelease(gitRepo, &release, "", []*AttachmentChange{
157
+
{
158
+
Action: "add",
159
+
Type: "external",
160
+
Name: "test",
161
+
ExternalURL: "https://forgejo.org/",
162
+
},
163
+
}))
164
+
assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, &release))
165
+
assert.Len(t, release.Attachments, 1)
166
+
assert.EqualValues(t, "test", release.Attachments[0].Name)
167
+
assert.EqualValues(t, "https://forgejo.org/", release.Attachments[0].ExternalURL)
168
+
169
+
release = repo_model.Release{
170
+
RepoID: repo.ID,
171
+
Repo: repo,
172
+
PublisherID: user.ID,
173
+
Publisher: user,
174
+
TagName: "v0.1.7",
175
+
Target: "65f1bf2",
176
+
Title: "v0.1.7 is released",
177
+
Note: "v0.1.7 is released",
178
+
IsDraft: false,
179
+
IsPrerelease: false,
180
+
IsTag: true,
181
+
}
182
+
assert.Error(t, CreateRelease(gitRepo, &repo_model.Release{}, "", []*AttachmentChange{
183
+
{
184
+
Action: "add",
185
+
Type: "external",
186
+
Name: "Click me",
187
+
// Invalid URL (API URL of current instance), this should result in an error
188
+
ExternalURL: "https://try.gitea.io/api/v1/user/follow",
189
+
},
190
+
}))
131
191
}
132
192
133
193
func TestRelease_Update(t *testing.T) {
···
153
213
IsDraft: false,
154
214
IsPrerelease: false,
155
215
IsTag: false,
156
-
}, nil, ""))
216
+
}, "", []*AttachmentChange{}))
157
217
release, err := repo_model.GetRelease(db.DefaultContext, repo.ID, "v1.1.1")
158
218
assert.NoError(t, err)
159
219
releaseCreatedUnix := release.CreatedUnix
160
220
time.Sleep(2 * time.Second) // sleep 2 seconds to ensure a different timestamp
161
221
release.Note = "Changed note"
162
-
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, nil, nil, nil, false))
222
+
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{}))
163
223
release, err = repo_model.GetReleaseByID(db.DefaultContext, release.ID)
164
224
assert.NoError(t, err)
165
225
assert.Equal(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
···
177
237
IsDraft: true,
178
238
IsPrerelease: false,
179
239
IsTag: false,
180
-
}, nil, ""))
240
+
}, "", []*AttachmentChange{}))
181
241
release, err = repo_model.GetRelease(db.DefaultContext, repo.ID, "v1.2.1")
182
242
assert.NoError(t, err)
183
243
releaseCreatedUnix = release.CreatedUnix
184
244
time.Sleep(2 * time.Second) // sleep 2 seconds to ensure a different timestamp
185
245
release.Title = "Changed title"
186
-
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, nil, nil, nil, false))
246
+
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{}))
187
247
release, err = repo_model.GetReleaseByID(db.DefaultContext, release.ID)
188
248
assert.NoError(t, err)
189
249
assert.Less(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
···
201
261
IsDraft: false,
202
262
IsPrerelease: true,
203
263
IsTag: false,
204
-
}, nil, ""))
264
+
}, "", []*AttachmentChange{}))
205
265
release, err = repo_model.GetRelease(db.DefaultContext, repo.ID, "v1.3.1")
206
266
assert.NoError(t, err)
207
267
releaseCreatedUnix = release.CreatedUnix
208
268
time.Sleep(2 * time.Second) // sleep 2 seconds to ensure a different timestamp
209
269
release.Title = "Changed title"
210
270
release.Note = "Changed note"
211
-
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, nil, nil, nil, false))
271
+
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{}))
212
272
release, err = repo_model.GetReleaseByID(db.DefaultContext, release.ID)
213
273
assert.NoError(t, err)
214
274
assert.Equal(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
···
227
287
IsPrerelease: false,
228
288
IsTag: false,
229
289
}
230
-
assert.NoError(t, CreateRelease(gitRepo, release, nil, ""))
290
+
assert.NoError(t, CreateRelease(gitRepo, release, "", []*AttachmentChange{}))
231
291
assert.Greater(t, release.ID, int64(0))
232
292
233
293
release.IsDraft = false
234
294
tagName := release.TagName
235
295
236
-
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, nil, nil, nil, false))
296
+
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{}))
237
297
release, err = repo_model.GetReleaseByID(db.DefaultContext, release.ID)
238
298
assert.NoError(t, err)
239
299
assert.Equal(t, tagName, release.TagName)
···
247
307
}, strings.NewReader(samplePayload), int64(len([]byte(samplePayload))))
248
308
assert.NoError(t, err)
249
309
250
-
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, []string{attach.UUID}, nil, nil, false))
310
+
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{
311
+
{
312
+
Action: "add",
313
+
Type: "attachment",
314
+
UUID: attach.UUID,
315
+
},
316
+
}))
251
317
assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, release))
252
318
assert.Len(t, release.Attachments, 1)
253
319
assert.EqualValues(t, attach.UUID, release.Attachments[0].UUID)
254
320
assert.EqualValues(t, release.ID, release.Attachments[0].ReleaseID)
255
321
assert.EqualValues(t, attach.Name, release.Attachments[0].Name)
322
+
assert.EqualValues(t, attach.ExternalURL, release.Attachments[0].ExternalURL)
256
323
257
324
// update the attachment name
258
-
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, nil, nil, map[string]string{
259
-
attach.UUID: "test2.txt",
260
-
}, false))
325
+
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{
326
+
{
327
+
Action: "update",
328
+
Name: "test2.txt",
329
+
UUID: attach.UUID,
330
+
},
331
+
}))
261
332
release.Attachments = nil
262
333
assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, release))
263
334
assert.Len(t, release.Attachments, 1)
264
335
assert.EqualValues(t, attach.UUID, release.Attachments[0].UUID)
265
336
assert.EqualValues(t, release.ID, release.Attachments[0].ReleaseID)
266
337
assert.EqualValues(t, "test2.txt", release.Attachments[0].Name)
338
+
assert.EqualValues(t, attach.ExternalURL, release.Attachments[0].ExternalURL)
267
339
268
340
// delete the attachment
269
-
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, nil, []string{attach.UUID}, nil, false))
341
+
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{
342
+
{
343
+
Action: "delete",
344
+
UUID: attach.UUID,
345
+
},
346
+
}))
270
347
release.Attachments = nil
271
348
assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, release))
272
349
assert.Empty(t, release.Attachments)
350
+
351
+
// Add new external attachment
352
+
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{
353
+
{
354
+
Action: "add",
355
+
Type: "external",
356
+
Name: "test",
357
+
ExternalURL: "https://forgejo.org/",
358
+
},
359
+
}))
360
+
assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, release))
361
+
assert.Len(t, release.Attachments, 1)
362
+
assert.EqualValues(t, release.ID, release.Attachments[0].ReleaseID)
363
+
assert.EqualValues(t, "test", release.Attachments[0].Name)
364
+
assert.EqualValues(t, "https://forgejo.org/", release.Attachments[0].ExternalURL)
365
+
externalAttachmentUUID := release.Attachments[0].UUID
366
+
367
+
// update the attachment name
368
+
assert.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{
369
+
{
370
+
Action: "update",
371
+
Name: "test2",
372
+
UUID: externalAttachmentUUID,
373
+
ExternalURL: "https://about.gitea.com/",
374
+
},
375
+
}))
376
+
release.Attachments = nil
377
+
assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, release))
378
+
assert.Len(t, release.Attachments, 1)
379
+
assert.EqualValues(t, externalAttachmentUUID, release.Attachments[0].UUID)
380
+
assert.EqualValues(t, release.ID, release.Attachments[0].ReleaseID)
381
+
assert.EqualValues(t, "test2", release.Attachments[0].Name)
382
+
assert.EqualValues(t, "https://about.gitea.com/", release.Attachments[0].ExternalURL)
273
383
}
274
384
275
385
func TestRelease_createTag(t *testing.T) {
+22
-10
templates/repo/release/list.tmpl
+22
-10
templates/repo/release/list.tmpl
···
72
72
<ul class="list">
73
73
{{if $hasArchiveLinks}}
74
74
<li>
75
-
<a class="archive-link tw-flex-1" href="{{$.RepoLink}}/archive/{{$release.TagName | PathEscapeSegments}}.zip" rel="nofollow"><strong>{{svg "octicon-file-zip" 16 "tw-mr-1"}}{{ctx.Locale.Tr "repo.release.source_code"}} (ZIP)</strong></a>
75
+
<a class="archive-link tw-flex-1 flex-text-inline tw-font-bold" href="{{$.RepoLink}}/archive/{{$release.TagName | PathEscapeSegments}}.zip" rel="nofollow">
76
+
{{svg "octicon-file-zip" 16 "tw-mr-1"}}{{ctx.Locale.Tr "repo.release.source_code"}} (ZIP)
77
+
</a>
76
78
<div class="tw-mr-1">
77
79
<span class="text grey">{{ctx.Locale.TrN .Release.ArchiveDownloadCount.Zip "repo.release.download_count_one" "repo.release.download_count_few" (ctx.Locale.PrettyNumber .Release.ArchiveDownloadCount.Zip)}}</span>
78
80
</div>
···
81
83
</span>
82
84
</li>
83
85
<li class="{{if $hasReleaseAttachment}}start-gap{{end}}">
84
-
<a class="archive-link tw-flex-1" href="{{$.RepoLink}}/archive/{{$release.TagName | PathEscapeSegments}}.tar.gz" rel="nofollow"><strong>{{svg "octicon-file-zip" 16 "tw-mr-1"}}{{ctx.Locale.Tr "repo.release.source_code"}} (TAR.GZ)</strong></a>
86
+
<a class="archive-link tw-flex-1 flex-text-inline tw-font-bold" href="{{$.RepoLink}}/archive/{{$release.TagName | PathEscapeSegments}}.tar.gz" rel="nofollow">
87
+
{{svg "octicon-file-zip" 16 "tw-mr-1"}}{{ctx.Locale.Tr "repo.release.source_code"}} (ZIP)
88
+
</a>
85
89
<div class="tw-mr-1">
86
90
<span class="text grey">{{ctx.Locale.TrN .Release.ArchiveDownloadCount.TarGz "repo.release.download_count_one" "repo.release.download_count_few" (ctx.Locale.PrettyNumber .Release.ArchiveDownloadCount.TarGz)}}</span>
87
91
</div>
···
92
96
{{if $hasReleaseAttachment}}<hr>{{end}}
93
97
{{end}}
94
98
{{range $release.Attachments}}
95
-
<li>
96
-
<a target="_blank" rel="nofollow" href="{{.DownloadURL}}" download>
97
-
<strong>{{svg "octicon-package" 16 "tw-mr-1"}}{{.Name}}</strong>
98
-
</a>
99
-
<div>
100
-
<span class="text grey">{{ctx.Locale.TrN .DownloadCount "repo.release.download_count_one" "repo.release.download_count_few" (ctx.Locale.PrettyNumber .DownloadCount)}} · {{.Size | ctx.Locale.TrSize}}</span>
101
-
</div>
102
-
</li>
99
+
{{if .ExternalURL}}
100
+
<li>
101
+
<a class="tw-flex-1 flex-text-inline tw-font-bold" target="_blank" rel="nofollow" href="{{.DownloadURL}}" download>
102
+
{{svg "octicon-link-external" 16 "tw-mr-1"}}{{.Name}}
103
+
</a>
104
+
</li>
105
+
{{else}}
106
+
<li>
107
+
<a class="tw-flex-1 flex-text-inline tw-font-bold" target="_blank" rel="nofollow" href="{{.DownloadURL}}" download>
108
+
{{svg "octicon-package" 16 "tw-mr-1"}}{{.Name}}
109
+
</a>
110
+
<div>
111
+
<span class="text grey">{{ctx.Locale.TrN .DownloadCount "repo.release.download_count_one" "repo.release.download_count_few" (ctx.Locale.PrettyNumber .DownloadCount)}} · {{.Size | ctx.Locale.TrSize}}</span>
112
+
</div>
113
+
</li>
114
+
{{end}}
103
115
{{end}}
104
116
</ul>
105
117
</details>
+34
-4
templates/repo/release/new.tmpl
+34
-4
templates/repo/release/new.tmpl
···
63
63
{{range .attachments}}
64
64
<div class="field flex-text-block" id="attachment-{{.ID}}">
65
65
<div class="flex-text-inline tw-flex-1">
66
-
<input name="attachment-edit-{{.UUID}}" class="attachment_edit" required value="{{.Name}}">
67
-
<input name="attachment-del-{{.UUID}}" type="hidden" value="false">
68
-
<span class="ui text grey tw-whitespace-nowrap">{{ctx.Locale.TrN .DownloadCount "repo.release.download_count_one" "repo.release.download_count_few" (ctx.Locale.PrettyNumber .DownloadCount)}} · {{.Size | ctx.Locale.TrSize}}</span>
66
+
<div class="flex-text-inline tw-shrink-0" title="{{ctx.Locale.Tr "repo.release.type_attachment"}}">
67
+
{{if .ExternalURL}}
68
+
{{svg "octicon-link-external" 16 "tw-mr-2"}}
69
+
{{else}}
70
+
{{svg "octicon-package" 16 "tw-mr-2"}}
71
+
{{end}}
72
+
</div>
73
+
<input name="attachment-edit-name-{{.UUID}}" placeholder="{{ctx.Locale.Tr "repo.release.asset_name"}}" class="attachment_edit" required value="{{.Name}}">
74
+
<input name="attachment-del-{{.UUID}}" type="hidden"
75
+
value="false">
76
+
{{if .ExternalURL}}
77
+
<input name="attachment-edit-exturl-{{.UUID}}" placeholder="{{ctx.Locale.Tr "repo.release.asset_external_url"}}" class="attachment_edit" required value="{{.ExternalURL}}">
78
+
{{else}}
79
+
<span class="ui text grey tw-whitespace-nowrap tw-ml-auto tw-pl-3">{{ctx.Locale.TrN
80
+
.DownloadCount "repo.release.download_count_one"
81
+
"repo.release.download_count_few" (ctx.Locale.PrettyNumber
82
+
.DownloadCount)}} · {{.Size | ctx.Locale.TrSize}}</span>
83
+
{{end}}
69
84
</div>
70
-
<a class="ui mini compact red button remove-rel-attach" data-id="{{.ID}}" data-uuid="{{.UUID}}">
85
+
<a class="ui mini red button remove-rel-attach tw-ml-3" data-id="{{.ID}}" data-uuid="{{.UUID}}">
71
86
{{ctx.Locale.Tr "remove"}}
72
87
</a>
73
88
</div>
74
89
{{end}}
90
+
<div class="field flex-text-block tw-hidden" id="attachment-template">
91
+
<div class="flex-text-inline tw-flex-1">
92
+
<div class="flex-text-inline tw-shrink-0" title="{{ctx.Locale.Tr "repo.release.type_external_asset"}}">
93
+
{{svg "octicon-link-external" 16 "tw-mr-2"}}
94
+
</div>
95
+
<input name="attachment-template-new-name" placeholder="{{ctx.Locale.Tr "repo.release.asset_name"}}" class="attachment_edit">
96
+
<input name="attachment-template-new-exturl" placeholder="{{ctx.Locale.Tr "repo.release.asset_external_url"}}" class="attachment_edit">
97
+
</div>
98
+
<a class="ui mini red button remove-rel-attach tw-ml-3">
99
+
{{ctx.Locale.Tr "remove"}}
100
+
</a>
101
+
</div>
102
+
<a class="ui mini button tw-float-right tw-mb-4 tw-mt-2" id="add-external-link">
103
+
{{ctx.Locale.Tr "repo.release.add_external_asset"}}
104
+
</a>
75
105
{{if .IsAttachmentEnabled}}
76
106
<div class="field">
77
107
{{template "repo/upload" .}}
+20
-1
templates/swagger/v1_json.tmpl
+20
-1
templates/swagger/v1_json.tmpl
···
13632
13632
},
13633
13633
{
13634
13634
"type": "file",
13635
-
"description": "attachment to upload",
13635
+
"description": "attachment to upload (this parameter is incompatible with `external_url`)",
13636
13636
"name": "attachment",
13637
+
"in": "formData"
13638
+
},
13639
+
{
13640
+
"type": "string",
13641
+
"description": "url to external asset (this parameter is incompatible with `attachment`)",
13642
+
"name": "external_url",
13637
13643
"in": "formData"
13638
13644
}
13639
13645
],
···
19010
19016
"format": "int64",
19011
19017
"x-go-name": "Size"
19012
19018
},
19019
+
"type": {
19020
+
"type": "string",
19021
+
"enum": [
19022
+
"attachment",
19023
+
"external"
19024
+
],
19025
+
"x-go-name": "Type"
19026
+
},
19013
19027
"uuid": {
19014
19028
"type": "string",
19015
19029
"x-go-name": "UUID"
···
20988
21002
"description": "EditAttachmentOptions options for editing attachments",
20989
21003
"type": "object",
20990
21004
"properties": {
21005
+
"browser_download_url": {
21006
+
"description": "(Can only be set if existing attachment is of external type)",
21007
+
"type": "string",
21008
+
"x-go-name": "DownloadURL"
21009
+
},
20991
21010
"name": {
20992
21011
"type": "string",
20993
21012
"x-go-name": "Name"
+67
tests/e2e/release.test.e2e.js
+67
tests/e2e/release.test.e2e.js
···
1
+
// @ts-check
2
+
import {test, expect} from '@playwright/test';
3
+
import {login_user, save_visual, load_logged_in_context} from './utils_e2e.js';
4
+
5
+
test.beforeAll(async ({browser}, workerInfo) => {
6
+
await login_user(browser, workerInfo, 'user2');
7
+
});
8
+
9
+
test.describe.configure({
10
+
timeout: 30000,
11
+
});
12
+
13
+
test('External Release Attachments', async ({browser, isMobile}, workerInfo) => {
14
+
test.skip(isMobile);
15
+
16
+
const context = await load_logged_in_context(browser, workerInfo, 'user2');
17
+
/** @type {import('@playwright/test').Page} */
18
+
const page = await context.newPage();
19
+
20
+
// Click "New Release"
21
+
await page.goto('/user2/repo2/releases');
22
+
await page.click('.button.small.primary');
23
+
24
+
// Fill out form and create new release
25
+
await page.fill('input[name=tag_name]', '2.0');
26
+
await page.fill('input[name=title]', '2.0');
27
+
await page.click('#add-external-link');
28
+
await page.click('#add-external-link');
29
+
await page.fill('input[name=attachment-new-name-2]', 'Test');
30
+
await page.fill('input[name=attachment-new-exturl-2]', 'https://forgejo.org/');
31
+
await page.click('.remove-rel-attach');
32
+
save_visual(page);
33
+
await page.click('.button.small.primary');
34
+
35
+
// Validate release page and click edit
36
+
await expect(page.locator('.download[open] li')).toHaveCount(3);
37
+
await expect(page.locator('.download[open] li:nth-of-type(3)')).toContainText('Test');
38
+
await expect(page.locator('.download[open] li:nth-of-type(3) a')).toHaveAttribute('href', 'https://forgejo.org/');
39
+
save_visual(page);
40
+
await page.locator('.octicon-pencil').first().click();
41
+
42
+
// Validate edit page and edit the release
43
+
await expect(page.locator('.attachment_edit:visible')).toHaveCount(2);
44
+
await expect(page.locator('.attachment_edit:visible').nth(0)).toHaveValue('Test');
45
+
await expect(page.locator('.attachment_edit:visible').nth(1)).toHaveValue('https://forgejo.org/');
46
+
await page.locator('.attachment_edit:visible').nth(0).fill('Test2');
47
+
await page.locator('.attachment_edit:visible').nth(1).fill('https://gitea.io/');
48
+
await page.click('#add-external-link');
49
+
await expect(page.locator('.attachment_edit:visible')).toHaveCount(4);
50
+
await page.locator('.attachment_edit:visible').nth(2).fill('Test3');
51
+
await page.locator('.attachment_edit:visible').nth(3).fill('https://gitea.com/');
52
+
save_visual(page);
53
+
await page.click('.button.small.primary');
54
+
55
+
// Validate release page and click edit
56
+
await expect(page.locator('.download[open] li')).toHaveCount(4);
57
+
await expect(page.locator('.download[open] li:nth-of-type(3)')).toContainText('Test2');
58
+
await expect(page.locator('.download[open] li:nth-of-type(3) a')).toHaveAttribute('href', 'https://gitea.io/');
59
+
await expect(page.locator('.download[open] li:nth-of-type(4)')).toContainText('Test3');
60
+
await expect(page.locator('.download[open] li:nth-of-type(4) a')).toHaveAttribute('href', 'https://gitea.com/');
61
+
save_visual(page);
62
+
await page.locator('.octicon-pencil').first().click();
63
+
64
+
// Delete release
65
+
await page.click('.delete-button');
66
+
await page.click('.button.ok');
67
+
});
+67
tests/integration/api_releases_test.go
+67
tests/integration/api_releases_test.go
···
347
347
348
348
assert.EqualValues(t, "stream.bin", attachment.Name)
349
349
assert.EqualValues(t, 104, attachment.Size)
350
+
assert.EqualValues(t, "attachment", attachment.Type)
350
351
})
351
352
}
352
353
···
385
386
assert.Equal(t, int64(1), release.ArchiveDownloadCount.TarGz)
386
387
assert.Equal(t, int64(0), release.ArchiveDownloadCount.Zip)
387
388
}
389
+
390
+
func TestAPIExternalAssetRelease(t *testing.T) {
391
+
defer tests.PrepareTestEnv(t)()
392
+
393
+
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
394
+
owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
395
+
session := loginUser(t, owner.LowerName)
396
+
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
397
+
398
+
r := createNewReleaseUsingAPI(t, token, owner, repo, "release-tag", "", "Release Tag", "test")
399
+
400
+
req := NewRequest(t, http.MethodPost, fmt.Sprintf("/api/v1/repos/%s/%s/releases/%d/assets?name=test-asset&external_url=https%%3A%%2F%%2Fforgejo.org%%2F", owner.Name, repo.Name, r.ID)).
401
+
AddTokenAuth(token)
402
+
resp := MakeRequest(t, req, http.StatusCreated)
403
+
404
+
var attachment *api.Attachment
405
+
DecodeJSON(t, resp, &attachment)
406
+
407
+
assert.EqualValues(t, "test-asset", attachment.Name)
408
+
assert.EqualValues(t, 0, attachment.Size)
409
+
assert.EqualValues(t, "https://forgejo.org/", attachment.DownloadURL)
410
+
assert.EqualValues(t, "external", attachment.Type)
411
+
}
412
+
413
+
func TestAPIDuplicateAssetRelease(t *testing.T) {
414
+
defer tests.PrepareTestEnv(t)()
415
+
416
+
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
417
+
owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
418
+
session := loginUser(t, owner.LowerName)
419
+
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
420
+
421
+
r := createNewReleaseUsingAPI(t, token, owner, repo, "release-tag", "", "Release Tag", "test")
422
+
423
+
filename := "image.png"
424
+
buff := generateImg()
425
+
body := &bytes.Buffer{}
426
+
427
+
writer := multipart.NewWriter(body)
428
+
part, err := writer.CreateFormFile("attachment", filename)
429
+
assert.NoError(t, err)
430
+
_, err = io.Copy(part, &buff)
431
+
assert.NoError(t, err)
432
+
err = writer.Close()
433
+
assert.NoError(t, err)
434
+
435
+
req := NewRequestWithBody(t, http.MethodPost, fmt.Sprintf("/api/v1/repos/%s/%s/releases/%d/assets?name=test-asset&external_url=https%%3A%%2F%%2Fforgejo.org%%2F", owner.Name, repo.Name, r.ID), body).
436
+
AddTokenAuth(token)
437
+
req.Header.Add("Content-Type", writer.FormDataContentType())
438
+
MakeRequest(t, req, http.StatusBadRequest)
439
+
}
440
+
441
+
func TestAPIMissingAssetRelease(t *testing.T) {
442
+
defer tests.PrepareTestEnv(t)()
443
+
444
+
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
445
+
owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
446
+
session := loginUser(t, owner.LowerName)
447
+
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
448
+
449
+
r := createNewReleaseUsingAPI(t, token, owner, repo, "release-tag", "", "Release Tag", "test")
450
+
451
+
req := NewRequest(t, http.MethodPost, fmt.Sprintf("/api/v1/repos/%s/%s/releases/%d/assets?name=test-asset", owner.Name, repo.Name, r.ID)).
452
+
AddTokenAuth(token)
453
+
MakeRequest(t, req, http.StatusBadRequest)
454
+
}
+1
-1
tests/integration/mirror_pull_test.go
+1
-1
tests/integration/mirror_pull_test.go
+3
-3
tests/integration/webhook_test.go
+3
-3
tests/integration/webhook_test.go
···
111
111
IsDraft: false,
112
112
IsPrerelease: false,
113
113
IsTag: false,
114
-
}, nil, ""))
114
+
}, "", nil))
115
115
116
116
// check the newly created hooktasks
117
117
hookTasksLenBefore := len(hookTasks)
···
125
125
126
126
t.Run("UpdateRelease", func(t *testing.T) {
127
127
rel := unittest.AssertExistsAndLoadBean(t, &repo_model.Release{RepoID: repo.ID, TagName: "v1.1.1"})
128
-
assert.NoError(t, release.UpdateRelease(db.DefaultContext, user, gitRepo, rel, nil, nil, nil, false))
128
+
assert.NoError(t, release.UpdateRelease(db.DefaultContext, user, gitRepo, rel, false, nil))
129
129
130
130
// check the newly created hooktasks
131
131
hookTasksLenBefore := len(hookTasks)
···
157
157
158
158
t.Run("UpdateRelease", func(t *testing.T) {
159
159
rel := unittest.AssertExistsAndLoadBean(t, &repo_model.Release{RepoID: repo.ID, TagName: "v1.1.2"})
160
-
assert.NoError(t, release.UpdateRelease(db.DefaultContext, user, gitRepo, rel, nil, nil, nil, true))
160
+
assert.NoError(t, release.UpdateRelease(db.DefaultContext, user, gitRepo, rel, true, nil))
161
161
162
162
// check the newly created hooktasks
163
163
hookTasksLenBefore := len(hookTasks)
+44
-2
web_src/js/features/repo-release.js
+44
-2
web_src/js/features/repo-release.js
···
6
6
el.addEventListener('click', (e) => {
7
7
const uuid = e.target.getAttribute('data-uuid');
8
8
const id = e.target.getAttribute('data-id');
9
-
document.querySelector(`input[name='attachment-del-${uuid}']`).value = 'true';
9
+
document.querySelector(`input[name='attachment-del-${uuid}']`).value =
10
+
'true';
10
11
hideElem(`#attachment-${id}`);
11
12
});
12
13
}
···
17
18
18
19
initTagNameEditor();
19
20
initRepoReleaseEditor();
21
+
initAddExternalLinkButton();
20
22
}
21
23
22
24
function initTagNameEditor() {
···
45
47
}
46
48
47
49
function initRepoReleaseEditor() {
48
-
const editor = document.querySelector('.repository.new.release .combo-markdown-editor');
50
+
const editor = document.querySelector(
51
+
'.repository.new.release .combo-markdown-editor',
52
+
);
49
53
if (!editor) {
50
54
return;
51
55
}
52
56
initComboMarkdownEditor(editor);
53
57
}
58
+
59
+
let newAttachmentCount = 0;
60
+
61
+
function initAddExternalLinkButton() {
62
+
const addExternalLinkButton = document.getElementById('add-external-link');
63
+
if (!addExternalLinkButton) return;
64
+
65
+
addExternalLinkButton.addEventListener('click', () => {
66
+
newAttachmentCount += 1;
67
+
const attachmentTemplate = document.getElementById('attachment-template');
68
+
69
+
const newAttachment = attachmentTemplate.cloneNode(true);
70
+
newAttachment.id = `attachment-N${newAttachmentCount}`;
71
+
newAttachment.classList.remove('tw-hidden');
72
+
73
+
const attachmentName = newAttachment.querySelector(
74
+
'input[name="attachment-template-new-name"]',
75
+
);
76
+
attachmentName.name = `attachment-new-name-${newAttachmentCount}`;
77
+
attachmentName.required = true;
78
+
79
+
const attachmentExtUrl = newAttachment.querySelector(
80
+
'input[name="attachment-template-new-exturl"]',
81
+
);
82
+
attachmentExtUrl.name = `attachment-new-exturl-${newAttachmentCount}`;
83
+
attachmentExtUrl.required = true;
84
+
85
+
const attachmentDel = newAttachment.querySelector('.remove-rel-attach');
86
+
attachmentDel.addEventListener('click', () => {
87
+
newAttachment.remove();
88
+
});
89
+
90
+
attachmentTemplate.parentNode.insertBefore(
91
+
newAttachment,
92
+
attachmentTemplate,
93
+
);
94
+
});
95
+
}