}
// GetAttachmentsByUUIDs returns attachment by given UUID list.
-func GetAttachmentsByUUIDs(uuids []string) ([]*Attachment, error) {
- return getAttachmentsByUUIDs(x, uuids)
+func GetAttachmentsByUUIDs(ctx DBContext, uuids []string) ([]*Attachment, error) {
+ return getAttachmentsByUUIDs(ctx.e, uuids)
}
func getAttachmentsByUUIDs(e Engine, uuids []string) ([]*Attachment, error) {
// DeleteAttachment deletes the given attachment and optionally the associated file.
func DeleteAttachment(a *Attachment, remove bool) error {
- _, err := DeleteAttachments([]*Attachment{a}, remove)
+ _, err := DeleteAttachments(DefaultDBContext(), []*Attachment{a}, remove)
return err
}
// DeleteAttachments deletes the given attachments and optionally the associated files.
-func DeleteAttachments(attachments []*Attachment, remove bool) (int, error) {
+func DeleteAttachments(ctx DBContext, attachments []*Attachment, remove bool) (int, error) {
if len(attachments) == 0 {
return 0, nil
}
ids = append(ids, a.ID)
}
- cnt, err := x.In("id", ids).NoAutoCondition().Delete(attachments[0])
+ cnt, err := ctx.e.In("id", ids).NoAutoCondition().Delete(attachments[0])
if err != nil {
return 0, err
}
return 0, err
}
- return DeleteAttachments(attachments, remove)
+ return DeleteAttachments(DefaultDBContext(), attachments, remove)
}
// DeleteAttachmentsByComment deletes all attachments associated with the given comment.
return 0, err
}
- return DeleteAttachments(attachments, remove)
+ return DeleteAttachments(DefaultDBContext(), attachments, remove)
}
// UpdateAttachment updates the given attachment in database
return updateAttachment(x, atta)
}
+// UpdateAttachmentByUUID Updates attachment via uuid
+func UpdateAttachmentByUUID(ctx DBContext, attach *Attachment, cols ...string) error {
+ if attach.UUID == "" {
+ return fmt.Errorf("Attachement uuid should not blank")
+ }
+ _, err := ctx.e.Where("uuid=?", attach.UUID).Cols(cols...).Update(attach)
+ return err
+}
+
func updateAttachment(e Engine, atta *Attachment) error {
var sess *xorm.Session
if atta.ID != 0 && atta.UUID == "" {
func TestGetAttachmentsByUUIDs(t *testing.T) {
assert.NoError(t, PrepareTestDatabase())
- attachList, err := GetAttachmentsByUUIDs([]string{"a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a17", "not-existing-uuid"})
+ attachList, err := GetAttachmentsByUUIDs(DefaultDBContext(), []string{"a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a17", "not-existing-uuid"})
assert.NoError(t, err)
assert.Equal(t, 2, len(attachList))
assert.Equal(t, "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", attachList[0].UUID)
package models
import (
+ "errors"
"fmt"
"sort"
"strings"
}
// AddReleaseAttachments adds a release attachments
-func AddReleaseAttachments(releaseID int64, attachmentUUIDs []string) (err error) {
+func AddReleaseAttachments(ctx DBContext, releaseID int64, attachmentUUIDs []string) (err error) {
// Check attachments
- attachments, err := GetAttachmentsByUUIDs(attachmentUUIDs)
+ attachments, err := getAttachmentsByUUIDs(ctx.e, attachmentUUIDs)
if err != nil {
return fmt.Errorf("GetAttachmentsByUUIDs [uuids: %v]: %v", attachmentUUIDs, err)
}
for i := range attachments {
+ if attachments[i].ReleaseID != 0 {
+ return errors.New("release permission denied")
+ }
attachments[i].ReleaseID = releaseID
// No assign value could be 0, so ignore AllCols().
- if _, err = x.ID(attachments[i].ID).Update(attachments[i]); err != nil {
+ if _, err = ctx.e.ID(attachments[i].ID).Update(attachments[i]); err != nil {
return fmt.Errorf("update attachment [%d]: %v", attachments[i].ID, err)
}
}
rel.Repo = ctx.Repo.Repository
rel.Publisher = ctx.User
- if err = releaseservice.UpdateReleaseOrCreatReleaseFromTag(ctx.User, ctx.Repo.GitRepo, rel, nil, true); err != nil {
- ctx.Error(http.StatusInternalServerError, "UpdateReleaseOrCreatReleaseFromTag", err)
+ if err = releaseservice.UpdateRelease(ctx.User, ctx.Repo.GitRepo, rel, nil, nil, nil); err != nil {
+ ctx.Error(http.StatusInternalServerError, "UpdateRelease", err)
return
}
}
if form.IsPrerelease != nil {
rel.IsPrerelease = *form.IsPrerelease
}
- if err := releaseservice.UpdateReleaseOrCreatReleaseFromTag(ctx.User, ctx.Repo.GitRepo, rel, nil, false); err != nil {
- ctx.Error(http.StatusInternalServerError, "UpdateReleaseOrCreatReleaseFromTag", err)
+ if err := releaseservice.UpdateRelease(ctx.User, ctx.Repo.GitRepo, rel, nil, nil, nil); err != nil {
+ ctx.Error(http.StatusInternalServerError, "UpdateRelease", err)
return
}
import (
"fmt"
+ "strings"
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/base"
ctx.Redirect(release.HTMLURL())
}
-// NewRelease render creating release page
+// NewRelease render creating or edit release page
func NewRelease(ctx *context.Context) {
ctx.Data["Title"] = ctx.Tr("repo.release.new_release")
ctx.Data["PageIsReleaseList"] = true
}
if rel != nil {
+ rel.Repo = ctx.Repo.Repository
+ if err := rel.LoadAttributes(); err != nil {
+ ctx.ServerError("LoadAttributes", err)
+ return
+ }
+
ctx.Data["tag_name"] = rel.TagName
ctx.Data["tag_target"] = rel.Target
ctx.Data["title"] = rel.Title
ctx.Data["content"] = rel.Note
+ ctx.Data["attachments"] = rel.Attachments
}
}
ctx.Data["IsAttachmentEnabled"] = setting.Attachment.Enabled
rel.PublisherID = ctx.User.ID
rel.IsTag = false
- if err = releaseservice.UpdateReleaseOrCreatReleaseFromTag(ctx.User, ctx.Repo.GitRepo, rel, attachmentUUIDs, true); err != nil {
+ if err = releaseservice.UpdateRelease(ctx.User, ctx.Repo.GitRepo, rel, attachmentUUIDs, nil, nil); err != nil {
ctx.Data["Err_TagName"] = true
- ctx.ServerError("UpdateReleaseOrCreatReleaseFromTag", err)
+ ctx.ServerError("UpdateRelease", err)
return
}
}
ctx.Data["prerelease"] = rel.IsPrerelease
ctx.Data["IsDraft"] = rel.IsDraft
+ rel.Repo = ctx.Repo.Repository
+ if err := rel.LoadAttributes(); err != nil {
+ ctx.ServerError("LoadAttributes", err)
+ return
+ }
+ ctx.Data["attachments"] = rel.Attachments
+
ctx.HTML(200, tplReleaseNew)
}
return
}
- var attachmentUUIDs []string
+ const delPrefix = "attachment-del-"
+ const editPrefix = "attachment-edit-"
+ var addAttachmentUUIDs, delAttachmentUUIDs []string
+ var editAttachments = make(map[string]string) // uuid -> new name
if setting.Attachment.Enabled {
- attachmentUUIDs = form.Files
+ addAttachmentUUIDs = form.Files
+ for k, v := range ctx.Req.Form {
+ if strings.HasPrefix(k, delPrefix) && v[0] == "true" {
+ delAttachmentUUIDs = append(delAttachmentUUIDs, k[len(delPrefix):])
+ } else if strings.HasPrefix(k, editPrefix) {
+ editAttachments[k[len(editPrefix):]] = v[0]
+ }
+ }
}
rel.Title = form.Title
rel.Note = form.Content
rel.IsDraft = len(form.Draft) > 0
rel.IsPrerelease = form.Prerelease
- if err = releaseservice.UpdateReleaseOrCreatReleaseFromTag(ctx.User, ctx.Repo.GitRepo, rel, attachmentUUIDs, false); err != nil {
+ if err = releaseservice.UpdateRelease(ctx.User, ctx.Repo.GitRepo,
+ rel, addAttachmentUUIDs, delAttachmentUUIDs, editAttachments); err != nil {
ctx.ServerError("UpdateRelease", err)
return
}
package release
import (
+ "errors"
"fmt"
"strings"
"code.gitea.io/gitea/modules/timeutil"
)
-func createTag(gitRepo *git.Repository, rel *models.Release, msg string) error {
+func createTag(gitRepo *git.Repository, rel *models.Release, msg string) (bool, error) {
+ var created bool
// Only actual create when publish.
if !rel.IsDraft {
if !gitRepo.IsTagExist(rel.TagName) {
commit, err := gitRepo.GetCommit(rel.Target)
if err != nil {
- return fmt.Errorf("GetCommit: %v", err)
+ return false, fmt.Errorf("GetCommit: %v", err)
}
// Trim '--' prefix to prevent command line argument vulnerability.
if len(msg) > 0 {
if err = gitRepo.CreateAnnotatedTag(rel.TagName, msg, commit.ID.String()); err != nil {
if strings.Contains(err.Error(), "is not a valid tag name") {
- return models.ErrInvalidTagName{
+ return false, models.ErrInvalidTagName{
TagName: rel.TagName,
}
}
- return err
+ return false, err
}
} else if err = gitRepo.CreateTag(rel.TagName, commit.ID.String()); err != nil {
if strings.Contains(err.Error(), "is not a valid tag name") {
- return models.ErrInvalidTagName{
+ return false, models.ErrInvalidTagName{
TagName: rel.TagName,
}
}
- return err
+ return false, err
}
+ created = true
rel.LowerTagName = strings.ToLower(rel.TagName)
// Prepare Notify
if err := rel.LoadAttributes(); err != nil {
log.Error("LoadAttributes: %v", err)
- return err
+ return false, err
}
notification.NotifyPushCommits(
rel.Publisher, rel.Repo,
}
commit, err := gitRepo.GetTagCommit(rel.TagName)
if err != nil {
- return fmt.Errorf("GetTagCommit: %v", err)
+ return false, fmt.Errorf("GetTagCommit: %v", err)
}
rel.Sha1 = commit.ID.String()
rel.NumCommits, err = commit.CommitsCount()
if err != nil {
- return fmt.Errorf("CommitsCount: %v", err)
+ return false, fmt.Errorf("CommitsCount: %v", err)
}
if rel.PublisherID <= 0 {
rel.PublisherID = u.ID
}
}
-
} else {
rel.CreatedUnix = timeutil.TimeStampNow()
}
- return nil
+ return created, nil
}
// CreateRelease creates a new release of repository.
}
}
- if err = createTag(gitRepo, rel, msg); err != nil {
+ if _, err = createTag(gitRepo, rel, msg); err != nil {
return err
}
return err
}
- if err = models.AddReleaseAttachments(rel.ID, attachmentUUIDs); err != nil {
+ if err = models.AddReleaseAttachments(models.DefaultDBContext(), rel.ID, attachmentUUIDs); err != nil {
return err
}
IsTag: true,
}
- if err = createTag(gitRepo, rel, msg); err != nil {
+ if _, err = createTag(gitRepo, rel, msg); err != nil {
return err
}
return err
}
-// UpdateReleaseOrCreatReleaseFromTag updates information of a release or create release from tag.
-func UpdateReleaseOrCreatReleaseFromTag(doer *models.User, gitRepo *git.Repository, rel *models.Release, attachmentUUIDs []string, isCreate bool) (err error) {
- if err = createTag(gitRepo, rel, ""); err != nil {
+// UpdateRelease updates information, attachments of a release and will create tag if it's not a draft and tag not exist.
+// addAttachmentUUIDs accept a slice of new created attachments' uuids which will be reassigned release_id as the created release
+// delAttachmentUUIDs accept a slice of attachments' uuids which will be deleted from the release
+// editAttachments accept a map of attachment uuid to new attachment name which will be updated with attachments.
+func UpdateRelease(doer *models.User, gitRepo *git.Repository, rel *models.Release,
+ addAttachmentUUIDs, delAttachmentUUIDs []string, editAttachments map[string]string) (err error) {
+ if rel.ID == 0 {
+ return errors.New("UpdateRelease only accepts an exist release")
+ }
+ isCreated, err := createTag(gitRepo, rel, "")
+ if err != nil {
return err
}
rel.LowerTagName = strings.ToLower(rel.TagName)
- if err = models.UpdateRelease(models.DefaultDBContext(), rel); err != nil {
+ ctx, commiter, err := models.TxDBContext()
+ if err != nil {
+ return err
+ }
+ defer commiter.Close()
+
+ if err = models.UpdateRelease(ctx, rel); err != nil {
return err
}
- if err = models.AddReleaseAttachments(rel.ID, attachmentUUIDs); err != nil {
- log.Error("AddReleaseAttachments: %v", err)
+ if err = models.AddReleaseAttachments(ctx, rel.ID, addAttachmentUUIDs); err != nil {
+ return fmt.Errorf("AddReleaseAttachments: %v", err)
+ }
+
+ var deletedUUIDsMap = make(map[string]bool)
+ if len(delAttachmentUUIDs) > 0 {
+ // Check attachments
+ attachments, err := models.GetAttachmentsByUUIDs(ctx, delAttachmentUUIDs)
+ if err != nil {
+ return fmt.Errorf("GetAttachmentsByUUIDs [uuids: %v]: %v", delAttachmentUUIDs, err)
+ }
+ for _, attach := range attachments {
+ if attach.ReleaseID != rel.ID {
+ return errors.New("delete attachement of release permission denied")
+ }
+ deletedUUIDsMap[attach.UUID] = true
+ }
+
+ if _, err := models.DeleteAttachments(ctx, attachments, false); err != nil {
+ return fmt.Errorf("DeleteAttachments [uuids: %v]: %v", delAttachmentUUIDs, err)
+ }
+ }
+
+ if len(editAttachments) > 0 {
+ var updateAttachmentsList = make([]string, 0, len(editAttachments))
+ for k := range editAttachments {
+ updateAttachmentsList = append(updateAttachmentsList, k)
+ }
+ // Check attachments
+ attachments, err := models.GetAttachmentsByUUIDs(ctx, updateAttachmentsList)
+ if err != nil {
+ return fmt.Errorf("GetAttachmentsByUUIDs [uuids: %v]: %v", updateAttachmentsList, err)
+ }
+ for _, attach := range attachments {
+ if attach.ReleaseID != rel.ID {
+ return errors.New("update attachement of release permission denied")
+ }
+ }
+
+ for uuid, newName := range editAttachments {
+ if !deletedUUIDsMap[uuid] {
+ if err = models.UpdateAttachmentByUUID(ctx, &models.Attachment{
+ UUID: uuid,
+ Name: newName,
+ }, "name"); err != nil {
+ return err
+ }
+ }
+ }
+ }
+
+ if err = commiter.Commit(); err != nil {
+ return
+ }
+
+ for _, uuid := range delAttachmentUUIDs {
+ if err := storage.Attachments.Delete(models.AttachmentRelativePath(uuid)); err != nil {
+ // Even delete files failed, but the attachments has been removed from database, so we
+ // should not return error but only record the error on logs.
+ // users have to delete this attachments manually or we should have a
+ // synchronize between database attachment table and attachment storage
+ log.Error("delete attachment[uuid: %s] failed: %v", uuid, err)
+ }
}
- if !isCreate {
+ if !isCreated {
notification.NotifyUpdateRelease(doer, rel)
return
}
import (
"path/filepath"
+ "strings"
"testing"
"time"
IsTag: false,
}, nil, ""))
- assert.NoError(t, CreateRelease(gitRepo, &models.Release{
+ attach, err := models.NewAttachment(&models.Attachment{
+ UploaderID: user.ID,
+ Name: "test.txt",
+ }, []byte{}, strings.NewReader("testtest"))
+ assert.NoError(t, err)
+
+ var release = models.Release{
RepoID: repo.ID,
PublisherID: user.ID,
TagName: "v0.1.5",
IsDraft: false,
IsPrerelease: false,
IsTag: true,
- }, nil, "test"))
+ }
+ assert.NoError(t, CreateRelease(gitRepo, &release, []string{attach.UUID}, "test"))
}
func TestRelease_Update(t *testing.T) {
releaseCreatedUnix := release.CreatedUnix
time.Sleep(2 * time.Second) // sleep 2 seconds to ensure a different timestamp
release.Note = "Changed note"
- assert.NoError(t, UpdateReleaseOrCreatReleaseFromTag(user, gitRepo, release, nil, false))
+ assert.NoError(t, UpdateRelease(user, gitRepo, release, nil, nil, nil))
release, err = models.GetReleaseByID(release.ID)
assert.NoError(t, err)
assert.Equal(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
releaseCreatedUnix = release.CreatedUnix
time.Sleep(2 * time.Second) // sleep 2 seconds to ensure a different timestamp
release.Title = "Changed title"
- assert.NoError(t, UpdateReleaseOrCreatReleaseFromTag(user, gitRepo, release, nil, false))
+ assert.NoError(t, UpdateRelease(user, gitRepo, release, nil, nil, nil))
release, err = models.GetReleaseByID(release.ID)
assert.NoError(t, err)
assert.Less(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
time.Sleep(2 * time.Second) // sleep 2 seconds to ensure a different timestamp
release.Title = "Changed title"
release.Note = "Changed note"
- assert.NoError(t, UpdateReleaseOrCreatReleaseFromTag(user, gitRepo, release, nil, false))
+ assert.NoError(t, UpdateRelease(user, gitRepo, release, nil, nil, nil))
release, err = models.GetReleaseByID(release.ID)
assert.NoError(t, err)
assert.Equal(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
+
+ // Test create release
+ release = &models.Release{
+ RepoID: repo.ID,
+ PublisherID: user.ID,
+ TagName: "v1.1.2",
+ Target: "master",
+ Title: "v1.1.2 is released",
+ Note: "v1.1.2 is released",
+ IsDraft: true,
+ IsPrerelease: false,
+ IsTag: false,
+ }
+ assert.NoError(t, CreateRelease(gitRepo, release, nil, ""))
+ assert.Greater(t, release.ID, int64(0))
+
+ release.IsDraft = false
+ tagName := release.TagName
+
+ assert.NoError(t, UpdateRelease(user, gitRepo, release, nil, nil, nil))
+ release, err = models.GetReleaseByID(release.ID)
+ assert.NoError(t, err)
+ assert.Equal(t, tagName, release.TagName)
+
+ // Add new attachments
+ attach, err := models.NewAttachment(&models.Attachment{
+ UploaderID: user.ID,
+ Name: "test.txt",
+ }, []byte{}, strings.NewReader("testtest"))
+ assert.NoError(t, err)
+
+ assert.NoError(t, UpdateRelease(user, gitRepo, release, []string{attach.UUID}, nil, nil))
+ assert.NoError(t, models.GetReleaseAttachments(release))
+ assert.EqualValues(t, 1, len(release.Attachments))
+ assert.EqualValues(t, attach.UUID, release.Attachments[0].UUID)
+ assert.EqualValues(t, release.ID, release.Attachments[0].ReleaseID)
+ assert.EqualValues(t, attach.Name, release.Attachments[0].Name)
+
+ // update the attachment name
+ assert.NoError(t, UpdateRelease(user, gitRepo, release, nil, nil, map[string]string{
+ attach.UUID: "test2.txt",
+ }))
+ release.Attachments = nil
+ assert.NoError(t, models.GetReleaseAttachments(release))
+ assert.EqualValues(t, 1, len(release.Attachments))
+ assert.EqualValues(t, attach.UUID, release.Attachments[0].UUID)
+ assert.EqualValues(t, release.ID, release.Attachments[0].ReleaseID)
+ assert.EqualValues(t, "test2.txt", release.Attachments[0].Name)
+
+ // delete the attachment
+ assert.NoError(t, UpdateRelease(user, gitRepo, release, nil, []string{attach.UUID}, nil))
+ release.Attachments = nil
+ assert.NoError(t, models.GetReleaseAttachments(release))
+ assert.EqualValues(t, 0, len(release.Attachments))
}
func TestRelease_createTag(t *testing.T) {
IsPrerelease: false,
IsTag: false,
}
- assert.NoError(t, createTag(gitRepo, release, ""))
+ _, err = createTag(gitRepo, release, "")
+ assert.NoError(t, err)
assert.NotEmpty(t, release.CreatedUnix)
releaseCreatedUnix := release.CreatedUnix
time.Sleep(2 * time.Second) // sleep 2 seconds to ensure a different timestamp
release.Note = "Changed note"
- assert.NoError(t, createTag(gitRepo, release, ""))
+ _, err = createTag(gitRepo, release, "")
+ assert.NoError(t, err)
assert.Equal(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
// Test a changed draft
IsPrerelease: false,
IsTag: false,
}
- assert.NoError(t, createTag(gitRepo, release, ""))
+ _, err = createTag(gitRepo, release, "")
+ assert.NoError(t, err)
releaseCreatedUnix = release.CreatedUnix
time.Sleep(2 * time.Second) // sleep 2 seconds to ensure a different timestamp
release.Title = "Changed title"
- assert.NoError(t, createTag(gitRepo, release, ""))
+ _, err = createTag(gitRepo, release, "")
+ assert.NoError(t, err)
assert.Less(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
// Test a changed pre-release
IsPrerelease: true,
IsTag: false,
}
- assert.NoError(t, createTag(gitRepo, release, ""))
+ _, err = createTag(gitRepo, release, "")
+ assert.NoError(t, err)
releaseCreatedUnix = release.CreatedUnix
time.Sleep(2 * time.Second) // sleep 2 seconds to ensure a different timestamp
release.Title = "Changed title"
release.Note = "Changed note"
- assert.NoError(t, createTag(gitRepo, release, ""))
+ _, err = createTag(gitRepo, release, "")
+ assert.NoError(t, err)
assert.Equal(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
}
{{if .Attachments}}
{{range .Attachments}}
<li>
- <span class="ui text right poping up" data-content="{{$.i18n.Tr "repo.release.download_count" (.DownloadCount | PrettyNumber)}}">
- {{svg "octicon-info"}}
+ <span class="ui text middle aligned right">
+ <span class="ui text grey">{{.Size | FileSize}}</span>
+ <span class="poping up" data-content="{{$.i18n.Tr "repo.release.download_count" (.DownloadCount | PrettyNumber)}}">
+ {{svg "octicon-info"}}
+ </span>
</span>
<a target="_blank" rel="noopener noreferrer" href="{{.DownloadURL}}">
<strong><span class="ui image" title='{{.Name}}'>{{svg "octicon-package" 16 "mr-2"}}</span>{{.Name}}</strong>
- <span class="ui text grey right">{{.Size | FileSize}}</span>
</a>
</li>
{{end}}
{{$.i18n.Tr "loading"}}
</div>
</div>
+ {{range .attachments}}
+ <div class="field" id="attachment-{{.ID}}">
+ <div class="ui right df ac wrap_remove">
+ <a class="ui mini compact red button remove-rel-attach" data-id="{{.ID}}" data-uuid="{{.UUID}}">
+ {{$.i18n.Tr "remove"}}
+ </a>
+ </div>
+ <div class="df ac">
+ <input name="attachment-edit-{{.UUID}}" class="mr-3 attachment_edit" required value="{{.Name}}"/>
+ <input name="attachment-del-{{.UUID}}" type="hidden" value="false"/>
+ <span class="ui text grey mr-3">{{.Size | FileSize}}</span>
+ <span class="poping up" data-content="{{$.i18n.Tr "repo.release.download_count" (.DownloadCount | PrettyNumber)}}">
+ {{svg "octicon-info"}}
+ </span>
+ </div>
+ </div>
+ {{end}}
{{if .IsAttachmentEnabled}}
<div class="field">
<div class="files"></div>
});
}
+function initRelease() {
+ $(document).on('click', '.remove-rel-attach', function() {
+ const uuid = $(this).data('uuid');
+ const id = $(this).data('id');
+ $(`input[name='attachment-del-${uuid}']`).attr('value', true);
+ $(`#attachment-${id}`).hide();
+ });
+}
+
function initPullRequestReview() {
if (window.location.hash && window.location.hash.startsWith('#issuecomment-')) {
const commentDiv = $(window.location.hash);
initNotificationsTable();
initPullRequestMergeInstruction();
initReleaseEditor();
+ initRelease();
const routes = {
'div.user.settings': initUserSettings,
margin-bottom: 1em;
}
}
+
+ .wrap_remove {
+ height: 38px;
+ }
+ .attachment_edit {
+ width: 450px !important;
+ }
}
}
projects / gitea.git / commitdiff