Delete RELEASE_ID column from RELEASE and RELEASE_ASSET

src/main/resources/update/gitbucket-core_4.21.xml

@@ -3,23 +3,21 @@
   <createTable tableName="RELEASE">
     <column name="USER_NAME" type="varchar(100)" nullable="false"/>
     <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="RELEASE_ID" type="int" nullable="false" autoIncrement="true" unique="true"/>
-    <column name="NAME" type="varchar(100)" nullable="false"/>
     <column name="TAG" type="varchar(100)" nullable="false"/>
+    <column name="NAME" type="varchar(100)" nullable="false"/>
     <column name="AUTHOR" type="varchar(100)" nullable="false"/>
     <column name="CONTENT" type="text" nullable="true"/>
     <column name="REGISTERED_DATE" type="datetime" nullable="false"/>
     <column name="UPDATED_DATE" type="datetime" nullable="false"/>
   </createTable>
 
-  <addPrimaryKey constraintName="IDX_RELEASE_PK" tableName="RELEASE" columnNames="USER_NAME, REPOSITORY_NAME, RELEASE_ID"/>
+  <addPrimaryKey constraintName="IDX_RELEASE_PK" tableName="RELEASE" columnNames="USER_NAME, REPOSITORY_NAME, TAG"/>
-  <addUniqueConstraint constraintName="IDX_RELEASE_UNIQ" tableName="RELEASE" columnNames="USER_NAME, REPOSITORY_NAME, TAG"/>
   <addForeignKeyConstraint constraintName="IDX_RELEASE_FK0" baseTableName="RELEASE" baseColumnNames="USER_NAME, REPOSITORY_NAME" referencedTableName="REPOSITORY" referencedColumnNames="USER_NAME, REPOSITORY_NAME"/>
 
   <createTable tableName="RELEASE_ASSET">
     <column name="USER_NAME" type="varchar(100)" nullable="false"/>
     <column name="REPOSITORY_NAME" type="varchar(100)" nullable="false"/>
-    <column name="RELEASE_ID" type="int" nullable="false"/>
+    <column name="TAG" type="varchar(100)" nullable="false"/>
     <column name="RELEASE_ASSET_ID" type="int" nullable="false" autoIncrement="true" unique="true"/>
     <column name="FILE_NAME" type="varchar(260)" nullable="false"/>
     <column name="LABEL" type="varchar(100)" nullable="true"/>
@@ -28,7 +26,6 @@
     <column name="REGISTERED_DATE" type="datetime" nullable="false"/>
     <column name="UPDATED_DATE" type="datetime" nullable="false"/>
   </createTable>
-  <addPrimaryKey constraintName="IDX_RELEASE_ASSET_PK" tableName="RELEASE_ASSET" columnNames="USER_NAME, REPOSITORY_NAME, RELEASE_ID, FILE_NAME"
+  <addPrimaryKey constraintName="IDX_RELEASE_ASSET_PK" tableName="RELEASE_ASSET" columnNames="USER_NAME, REPOSITORY_NAME, TAG, FILE_NAME"/>
-  />
+  <addForeignKeyConstraint constraintName="IDX_RELEASE_ASSET_FK1" baseTableName="RELEASE_ASSET" baseColumnNames="USER_NAME, REPOSITORY_NAME, TAG" referencedTableName="RELEASE" referencedColumnNames="USER_NAME, REPOSITORY_NAME, TAG"/>
-  <addForeignKeyConstraint constraintName="IDX_RELEASE_ASSET_FK1" baseTableName="RELEASE_ASSET" baseColumnNames="USER_NAME, REPOSITORY_NAME, RELEASE_ID" referencedTableName="RELEASE" referencedColumnNames="USER_NAME, REPOSITORY_NAME, RELEASE_ID"/>
 </changeSet>

src/main/scala/gitbucket/core/controller/ReleasesController.scala

@@ -51,24 +51,25 @@ trait ReleaseControllerBase extends ControllerBase {
       hasDeveloperRole(repository.owner, repository.name, context.loginAccount))
   })
 
-  get("/:owner/:repository/releases/:id")(referrersOnly {repository =>
+  get("/:owner/:repository/releases/:tag")(referrersOnly { repository =>
-    val id = params("id")
+    val tag = params("tag")
-    getRelease(repository.owner, repository.name, id).map{ release =>
+    getRelease(repository.owner, repository.name, tag).map { release =>
-      html.release(release, getReleaseAssets(repository.owner, repository.name, id), hasDeveloperRole(repository.owner, repository.name, context.loginAccount), repository)
+      html.release(release, getReleaseAssets(repository.owner, repository.name, tag), hasDeveloperRole(repository.owner, repository.name, context.loginAccount), repository)
     }.getOrElse(NotFound())
   })
 
-  get("/:owner/:repository/releases/:id/assets/:fileId")(referrersOnly {repository =>
+  get("/:owner/:repository/releases/:tag/assets/:fileId")(referrersOnly {repository =>
-    val releaseId = params("id")
+    val tag = params("tag")
     val fileId = params("fileId")
     (for {
-      release <- getRelease(repository.owner, repository.name, releaseId)
+      _     <- repository.tags.find(_.name == tag)
-      asset   <- getReleaseAsset(repository.owner, repository.name, releaseId, fileId)
+      _     <- getRelease(repository.owner, repository.name, tag)
+      asset <- getReleaseAsset(repository.owner, repository.name, tag, fileId)
     } yield {
       response.setHeader("Content-Disposition", s"attachment; filename=${asset.label}")
       Some(RawData(
         FileUtil.getMimeType(asset.label),
-        new File(getReleaseFilesDir(repository.owner, repository.name), release.tag + "/" + fileId)
+        new File(getReleaseFilesDir(repository.owner, repository.name), tag + "/" + fileId)
       ))
     }).getOrElse(NotFound())
   })
@@ -82,7 +83,7 @@ trait ReleaseControllerBase extends ControllerBase {
     val loginAccount = context.loginAccount.get
 
     // Insert into RELEASE
-    val release = createRelease(repository.owner, repository.name, form.name, form.content, tag, loginAccount)
+    createRelease(repository.owner, repository.name, form.name, form.content, tag, loginAccount)
 
     // Insert into RELEASE_ASSET
     request.getParameterNames.asScala.filter(_.startsWith("file:")).foreach { paramName =>
@@ -90,50 +91,51 @@ trait ReleaseControllerBase extends ControllerBase {
       val fileName = params(paramName)
       val size = new java.io.File(getReleaseFilesDir(repository.owner, repository.name), tag + "/" + fileId).length
 
-      createReleaseAsset(repository.owner, repository.name, release.releaseId, fileId, fileName, size, loginAccount)
+      createReleaseAsset(repository.owner, repository.name, tag, fileId, fileName, size, loginAccount)
     }
 
-    recordReleaseActivity(repository.owner, repository.name, loginAccount.userName, release.releaseId, release.name)
+    recordReleaseActivity(repository.owner, repository.name, loginAccount.userName, form.name)
 
-    redirect(s"/${release.userName}/${release.repositoryName}/releases/${release.releaseId}")
+    redirect(s"/${repository.owner}/${repository.name}/releases/${tag}")
   })
 
-  get("/:owner/:repository/releases/:id/edit")(writableUsersOnly {repository =>
+  get("/:owner/:repository/releases/:tag/edit")(writableUsersOnly {repository =>
-    val releaseId = params("id").toInt
+    val tag = params("tag")
-    getRelease(repository.owner, repository.name, releaseId).map { release =>
+
-      html.form(repository, release.tag, Some(release, getReleaseAssets(repository.owner, repository.name, releaseId)))
+    getRelease(repository.owner, repository.name, tag).map { release =>
+      html.form(repository, release.tag, Some(release, getReleaseAssets(repository.owner, repository.name, tag)))
     }.getOrElse(NotFound())
   })
 
-  post("/:owner/:repository/releases/:id/edit", releaseForm)(writableUsersOnly { (form, repository) =>
+  post("/:owner/:repository/releases/:tag/edit", releaseForm)(writableUsersOnly { (form, repository) =>
-    val releaseId = params("id").toInt
+    val tag = params("tag")
     val loginAccount = context.loginAccount.get
 
-    getRelease(repository.owner, repository.name, releaseId).map { release =>
+    getRelease(repository.owner, repository.name, tag).map { release =>
       // Update RELEASE
-      updateRelease(repository.owner, repository.name, releaseId, form.name, form.content)
+      updateRelease(repository.owner, repository.name, tag, form.name, form.content)
 
       // Delete and Insert RELEASE_ASSET
-      deleteReleaseAssets(repository.owner, repository.name, releaseId)
+      deleteReleaseAssets(repository.owner, repository.name, tag)
 
       request.getParameterNames.asScala.filter(_.startsWith("file:")).foreach { paramName =>
         val Array(_, fileId) = paramName.split(":")
         val fileName = params(paramName)
         val size = new java.io.File(getReleaseFilesDir(repository.owner, repository.name), release.tag + "/" + fileId).length
 
-        createReleaseAsset(repository.owner, repository.name, release.releaseId, fileId, fileName, size, loginAccount)
+        createReleaseAsset(repository.owner, repository.name, tag, fileId, fileName, size, loginAccount)
       }
 
-      redirect(s"/${release.userName}/${release.repositoryName}/releases/${release.releaseId}")
+      redirect(s"/${release.userName}/${release.repositoryName}/releases/${tag}")
     }.getOrElse(NotFound())
   })
 
-  post("/:owner/:repository/releases/:id/delete")(writableUsersOnly { repository =>
+  post("/:owner/:repository/releases/:tag/delete")(writableUsersOnly { repository =>
-    val releaseId = params("id")
+    val tag = params("tag")
-    getRelease(repository.owner, repository.name, releaseId).foreach { release =>
+    getRelease(repository.owner, repository.name, tag).foreach { release =>
       FileUtils.deleteDirectory(new File(getReleaseFilesDir(repository.owner, repository.name), release.tag))
     }
-    deleteRelease(repository.owner, repository.name, releaseId)
+    deleteRelease(repository.owner, repository.name, tag)
     redirect(s"/${repository.owner}/${repository.name}/releases")
   })
 

src/main/scala/gitbucket/core/model/Release.scala

@@ -9,7 +9,6 @@ trait ReleaseComponent extends TemplateComponent {
   lazy val Releases = TableQuery[Releases]
 
   class Releases(tag_ : Tag) extends Table[Release](tag_, "RELEASE") with BasicTemplate {
-    val releaseId = column[Int]("RELEASE_ID", O AutoInc)
     val name = column[String]("NAME")
     val tag = column[String]("TAG")
     val author = column[String]("AUTHOR")
@@ -17,29 +16,15 @@ trait ReleaseComponent extends TemplateComponent {
     val registeredDate = column[java.util.Date]("REGISTERED_DATE")
     val updatedDate = column[java.util.Date]("UPDATED_DATE")
 
-    def * = (userName, repositoryName, releaseId, name, tag, author, content, registeredDate, updatedDate) <> (Release.tupled, Release.unapply)
+    def * = (userName, repositoryName, name, tag, author, content, registeredDate, updatedDate) <> (Release.tupled, Release.unapply)
-
+    def byPrimaryKey(owner: String, repository: String, tag: String) = byTag(owner, repository, tag)
-    def byPrimaryKey(owner: String, repository: String, releaseId: Int) = byRelease(owner, repository, releaseId)
+    def byTag(owner: String, repository: String, tag: String) = byRepository(owner, repository) && (this.tag === tag.bind)
-
-    def byTag(owner: String, repository: String, tag: String) =
-      byRepository(owner, repository) && (this.tag === tag.bind)
-
-    def byTag(userName: Rep[String], repositoryName: Rep[String], tag: Rep[String]) =
-      byRepository(userName, repositoryName) && (this.tag === tag)
-
-    def byRelease(owner: String, repository: String, releaseId: Int) =
-      byRepository(owner, repository) && (this.releaseId === releaseId.bind)
-
-    def byRelease(userName: Rep[String], repositoryName: Rep[String], releaseId: Rep[Int]) =
-      byRepository(userName, repositoryName) && (this.releaseId === releaseId)
   }
-
 }
 
 case class Release(
   userName: String,
   repositoryName: String,
-  releaseId: Int = 0,
   name: String,
   tag: String,
   author: String,

src/main/scala/gitbucket/core/model/ReleasesAsset.scala

@@ -10,8 +10,8 @@ trait ReleaseAssetComponent extends TemplateComponent {
 
   lazy val ReleaseAssets = TableQuery[ReleaseAssets]
 
-  class ReleaseAssets(tag : Tag) extends Table[ReleaseAsset](tag, "RELEASE_ASSET") with BasicTemplate {
+  class ReleaseAssets(tag_ : Tag) extends Table[ReleaseAsset](tag_, "RELEASE_ASSET") with BasicTemplate {
-    val releaseId = column[Int]("RELEASE_ID")
+    val tag = column[String]("TAG")
     val releaseAssetId = column[Int]("RELEASE_ASSET_ID", O AutoInc)
     val fileName = column[String]("FILE_NAME")
     val label = column[String]("LABEL")
@@ -20,23 +20,16 @@ trait ReleaseAssetComponent extends TemplateComponent {
     val registeredDate = column[Date]("REGISTERED_DATE")
     val updatedDate = column[Date]("UPDATED_DATE")
 
-    def * = (userName, repositoryName, releaseId, releaseAssetId, fileName, label, size, uploader, registeredDate, updatedDate) <> (ReleaseAsset.tupled, ReleaseAsset.unapply)
+    def * = (userName, repositoryName, tag, releaseAssetId, fileName, label, size, uploader, registeredDate, updatedDate) <> (ReleaseAsset.tupled, ReleaseAsset.unapply)
-
+    def byPrimaryKey(owner: String, repository: String, tag: String, fileName: String) = byTag(owner, repository, tag) && (this.fileName === fileName.bind)
-    def byPrimaryKey(owner: String, repository: String, releaseId: Int, fileName: String) = byRelease(owner, repository, releaseId) && (this.fileName === fileName.bind)
+    def byTag(owner: String, repository: String, tag: String) = byRepository(owner, repository) && (this.tag === tag.bind)
-
-    def byRelease(owner: String, repository: String, releaseId: Int) =
-      byRepository(owner, repository) && (this.releaseId === releaseId.bind)
-
-    def byRelease(userName: Rep[String], repositoryName: Rep[String], releaseId: Rep[Int]) =
-      byRepository(userName, repositoryName) && (this.releaseId === releaseId)
   }
-
 }
 
 case class ReleaseAsset(
   userName: String,
   repositoryName: String,
-  releaseId: Int,
+  tag: String,
   releaseAssetId: Int = 0,
   fileName: String,
   label: String,

src/main/scala/gitbucket/core/service/ActivityService.scala

@@ -190,7 +190,7 @@ trait ActivityService {
       Some(message),
       currentDate)
 
-  def recordReleaseActivity(userName: String, repositoryName: String, activityUserName: String, releaseId: Int, name: String)(implicit s: Session): Unit =
+  def recordReleaseActivity(userName: String, repositoryName: String, activityUserName: String, name: String)(implicit s: Session): Unit =
     Activities insert Activity(userName, repositoryName, activityUserName,
       "release",
       s"[user:${activityUserName}] released ${name} at [repo:${userName}/${repositoryName}]",

src/main/scala/gitbucket/core/service/ReleaseService.scala

@@ -2,7 +2,6 @@ package gitbucket.core.service
 
 import gitbucket.core.controller.Context
 import gitbucket.core.model.{Account, Release, ReleaseAsset}
-import gitbucket.core.util.StringUtil._
 import gitbucket.core.model.Profile.profile.blockingApi._
 import gitbucket.core.model.Profile._
 import gitbucket.core.model.Profile.dateColumnType
@@ -10,11 +9,11 @@ import gitbucket.core.model.Profile.dateColumnType
 trait ReleaseService {
   self: AccountService with RepositoryService =>
 
-  def createReleaseAsset(owner: String, repository: String, releaseId: Int, fileName: String, label: String, size: Long, loginAccount: Account)(implicit s: Session): Unit = {
+  def createReleaseAsset(owner: String, repository: String, tag: String, fileName: String, label: String, size: Long, loginAccount: Account)(implicit s: Session): Unit = {
     ReleaseAssets insert ReleaseAsset(
       userName       = owner,
       repositoryName = repository,
-      releaseId      = releaseId,
+      tag            = tag,
       fileName       = fileName,
       label          = label,
       size           = size,
@@ -24,34 +23,25 @@ trait ReleaseService {
     )
   }
 
-  def getReleaseAssets(owner: String, repository: String, releaseId: Int)(implicit s: Session): Seq[ReleaseAsset] = {
+  def getReleaseAssets(owner: String, repository: String, tag: String)(implicit s: Session): Seq[ReleaseAsset] = {
-    ReleaseAssets.filter(x => x.byRelease(owner, repository, releaseId)).list
+    ReleaseAssets.filter(x => x.byTag(owner, repository, tag)).list
-  }
-
-  def getReleaseAssets(owner: String, repository: String, releaseId: String)(implicit s: Session): Seq[ReleaseAsset] = {
-    if (isInteger(releaseId))
-      getReleaseAssets(owner, repository, releaseId.toInt)
-    else
-      Seq.empty
   }
 
   def getReleaseAssetsMap(owner: String, repository: String)(implicit s: Session): Map[Release, Seq[ReleaseAsset]] = {
     val releases = getReleases(owner, repository)
-    releases.map(rel => (rel -> getReleaseAssets(owner, repository, rel.releaseId))).toMap
+    releases.map(rel => (rel -> getReleaseAssets(owner, repository, rel.tag))).toMap
   }
 
-  def getReleaseAsset(owner: String, repository: String, releaseId: String, fileId: String)(implicit s: Session): Option[ReleaseAsset] = {
+  def getReleaseAsset(owner: String, repository: String, tag: String, fileId: String)(implicit s: Session): Option[ReleaseAsset] = {
-    if (isInteger(releaseId))
+    ReleaseAssets.filter(x => x.byPrimaryKey(owner, repository, tag, fileId)) firstOption
-      ReleaseAssets.filter(x => x.byPrimaryKey(owner, repository, releaseId.toInt, fileId)) firstOption
-    else None
   }
 
-  def deleteReleaseAssets(owner: String, repository: String, releaseId: Int)(implicit s: Session): Unit = {
+  def deleteReleaseAssets(owner: String, repository: String, tag: String)(implicit s: Session): Unit = {
-    ReleaseAssets.filter(x => x.byRelease(owner, repository, releaseId)) delete
+    ReleaseAssets.filter(x => x.byTag(owner, repository, tag)) delete
   }
 
   def createRelease(owner: String, repository: String, name: String, content: Option[String], tag: String,
-                    loginAccount: Account)(implicit context: Context, s: Session): Release = {
+                    loginAccount: Account)(implicit context: Context, s: Session): Int = {
     Releases insert Release(
       userName       = owner,
       repositoryName = repository,
@@ -62,39 +52,36 @@ trait ReleaseService {
       registeredDate = currentDate,
       updatedDate    = currentDate
     )
-    getReleaseByTag(owner, repository, tag).get
   }
 
   def getReleases(owner: String, repository: String)(implicit s: Session): Seq[Release] = {
     Releases.filter(x => x.byRepository(owner, repository)).list
   }
 
-  def getRelease(owner: String, repository: String, releaseId: Int)(implicit s: Session): Option[Release] = {
+  def getRelease(owner: String, repository: String, tag: String)(implicit s: Session): Option[Release] = {
-    Releases filter (_.byPrimaryKey(owner, repository, releaseId)) firstOption
+    //Releases filter (_.byPrimaryKey(owner, repository, releaseId)) firstOption
-  }
-
-  def getReleaseByTag(owner: String, repository: String, tag: String)(implicit s: Session): Option[Release] = {
     Releases filter (_.byTag(owner, repository, tag)) firstOption
   }
 
-  def getRelease(owner: String, repository: String, releaseId: String)(implicit s: Session): Option[Release] = {
+//  def getReleaseByTag(owner: String, repository: String, tag: String)(implicit s: Session): Option[Release] = {
-    if (isInteger(releaseId))
+//    Releases filter (_.byTag(owner, repository, tag)) firstOption
-      getRelease(owner, repository, releaseId.toInt)
+//  }
-    else None
+//
-  }
+//  def getRelease(owner: String, repository: String, releaseId: String)(implicit s: Session): Option[Release] = {
+//    if (isInteger(releaseId))
+//      getRelease(owner, repository, releaseId.toInt)
+//    else None
+//  }
 
-  def updateRelease(owner: String, repository: String, releaseId: Int, title: String, content: Option[String])(implicit s: Session): Int = {
+  def updateRelease(owner: String, repository: String, tag: String, title: String, content: Option[String])(implicit s: Session): Int = {
     Releases
-      .filter (_.byPrimaryKey(owner, repository, releaseId))
+      .filter (_.byPrimaryKey(owner, repository, tag))
       .map { t => (t.name, t.content, t.updatedDate) }
       .update (title, content, currentDate)
   }
 
-  def deleteRelease(owner: String, repository: String, releaseId: String)(implicit s: Session): Unit = {
+  def deleteRelease(owner: String, repository: String, tag: String)(implicit s: Session): Unit = {
-    if (isInteger(releaseId)){
+    deleteReleaseAssets(owner, repository, tag)
-      val relId = releaseId.toInt
+    Releases filter (_.byPrimaryKey(owner, repository, tag)) delete
-      deleteReleaseAssets(owner, repository, relId)
-      Releases filter (_.byPrimaryKey(owner, repository, relId)) delete
-    }
   }
 }

src/main/twirl/gitbucket/core/releases/form.scala.html

@@ -2,18 +2,9 @@
   tag: String,
   release: Option[(gitbucket.core.model.Release, Seq[gitbucket.core.model.ReleaseAsset])])(implicit context: gitbucket.core.controller.Context)
 @import gitbucket.core.view.helpers
-
-@action = {
-  @release.map { case (release, _) =>
-    @helpers.url(repository)/releases/@release.releaseId/edit
-  }.getOrElse {
-    @helpers.url(repository)/releases/@helpers.encodeRefName(tag)/create
-  }
-}
-
 @gitbucket.core.html.main(s"New Release - ${repository.owner}/${repository.name}", Some(repository)){
   @gitbucket.core.html.menu("releases", repository){
-    <form action="@action.toString.trim" method="POST" validate="true" class="form-group">
+    <form action="@helpers.url(repository)/releases/@helpers.encodeRefName(tag)/@if(release.isEmpty){create}else{edit}" method="POST" validate="true" class="form-group">
       <div class="row-fluid">
         <div class="co`l-md-12">
           @if(release.isEmpty){

src/main/twirl/gitbucket/core/releases/list.scala.html

@@ -20,7 +20,7 @@
             <div class="col-md-10" style="border-left: 1px solid #eee">
               <div class="release-note markdown-body">
                 @release.map { case (release, assets) =>
-                  <h3><a href="@helpers.url(repository)/releases/@release.releaseId">@release.name</a></h3>
+                  <h3><a href="@helpers.url(repository)/releases/@release.tag">@release.name</a></h3>
                   <p class="muted">
                     @helpers.avatar(release.author, 20) @helpers.user(release.author, styleClass="username") released this @gitbucket.core.helper.html.datetimeago(release.registeredDate)
                   </p>
@@ -45,7 +45,7 @@
                   @release.map { case (release, assets) =>
                     @assets.map { asset =>
                       <li>
-                        <i class="octicon octicon-file"></i><a href="@helpers.url(repository)/releases/@release.releaseId/assets/@asset.fileName">@asset.label</a>
+                        <i class="octicon octicon-file"></i><a href="@helpers.url(repository)/releases/@release.tag/assets/@asset.fileName">@asset.label</a>
                         <span class="label label-default">@helpers.readableSize(Some(asset.size))</span>
                       </li>
                     }

src/main/twirl/gitbucket/core/releases/release.scala.html

@@ -3,7 +3,7 @@
   hasWritePermission: Boolean,
   repository: gitbucket.core.service.RepositoryService.RepositoryInfo)(implicit context: gitbucket.core.controller.Context)
 @import gitbucket.core.view.helpers
-@gitbucket.core.html.main(s"${release.name} - Release ${release.releaseId} - ${repository.owner}/${repository.name}", Some(repository)){
+@gitbucket.core.html.main(s"Release ${release.name} - ${repository.owner}/${repository.name}", Some(repository)){
   @gitbucket.core.html.menu("releases", repository){
     <div class="row">
       <div class="col-md-2 text-right">
@@ -21,8 +21,8 @@
             @release.name
             @if(hasWritePermission){
               <div class="pull-right">
-                <form method="POST" action="@helpers.url(repository)/releases/@release.releaseId/delete" id="delete-form">
+                <form method="POST" action="@helpers.url(repository)/releases/@release.tag/delete" id="delete-form">
-                  <a class="btn btn-default" href="@helpers.url(repository)/releases/@release.releaseId/edit" id="edit">Edit</a>
+                  <a class="btn btn-default" href="@helpers.url(repository)/releases/@release.tag/edit" id="edit">Edit</a>
                   <input type="submit" class="btn btn-danger" value="Delete">
                 </form>
               </div>
@@ -44,7 +44,7 @@
           <ul style="list-style: none; padding-left: 8px;" id="attachedFiles">
             @assets.map{ asset =>
               <li>
-                <i class="octicon octicon-file"></i><a href="@helpers.url(repository)/releases/@release.releaseId/assets/@asset.fileName">@asset.label</a>
+                <i class="octicon octicon-file"></i><a href="@helpers.url(repository)/releases/@release.tag/assets/@asset.fileName">@asset.label</a>
                 <span class="label label-default">@helpers.readableSize(Some(asset.size))</span>
               </li>
             }