Nemcio/GitBucket
1
0
Fork 0
mirror of https://github.com/gitbucket/gitbucket.git synced 2026-05-07 06:15:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

Moving to Quill

Browse Source
This commit is contained in:
Naoki Takezoe
2016-03-10 16:40:25 +09:00
parent dad29d93c2
commit 682f3a4c10
15 changed files with 124 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/scala/gitbucket/core/api/ApiRepository.scala
View File

@@ -39,7 +39,7 @@ object ApiRepository{
description = repository.description.getOrElse(""),
watchers = 0,
forks = forkedCount,
`private` = repository.isPrivate,
`private` = repository.`private`,
default_branch = repository.defaultBranch,
owner = owner
)(urlIsHtmlUrl)

2
src/main/scala/gitbucket/core/controller/AccountController.scala
View File

@@ -389,7 +389,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
repositoryName = repository.name,
userName = accountName,
description = repository.repository.description,
isPrivate = repository.repository.isPrivate,
isPrivate = repository.repository.`private`,
originRepositoryName = Some(originRepositoryName),
originUserName = Some(originUserName),
parentRepositoryName = Some(repository.name),

2
src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala
View File

@@ -87,7 +87,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
repository.name,
form.description,
repository.repository.parentUserName.map { _ =>
repository.repository.isPrivate
repository.repository.`private`
} getOrElse form.isPrivate
)
// Change repository name

2
src/main/scala/gitbucket/core/model/Repository.scala
View File

@@ -26,7 +26,7 @@ trait RepositoryComponent extends TemplateComponent { self: Profile =>
case class Repository(
userName: String,
repositoryName: String,
isPrivate: Boolean,
`private`: Boolean,
description: Option[String],
defaultBranch: String,
registeredDate: java.util.Date,

28
src/main/scala/gitbucket/core/service/AccessTokenService.scala
View File

@@ -42,30 +42,22 @@ trait AccessTokenService {
(tokenId, token)
}
def getAccountByAccessToken(token: String)(implicit s: Session): Option[Account] = {
db.run(
quote { (tokenHash: String) =>
def getAccountByAccessToken(token: String)(implicit s: Session): Option[Account] =
db.run(quote { (tokenHash: String) =>
query[AccessToken].filter(_.tokenHash == tokenHash)
.join(query[Account]).on { (t, a) => t.userName == a.userName && a.registeredDate == false }
.map { case (t, a) => a }
}
)(tokenToHash(token)).headOption
}
})(tokenToHash(token)).headOption
def getAccessTokens(userName: String)(implicit s: Session): List[AccessToken] = {
db.run(
quote { (userName: String) =>
query[AccessToken].filter(_.userName == userName).sortBy(_.accessTokenId)(Ord.desc)
}
)(userName)
}
def getAccessTokens(userName: String)(implicit s: Session): List[AccessToken] =
db.run(quote { (userName: String) =>
query[AccessToken].filter(_.userName == userName).sortBy(_.accessTokenId)(Ord.desc)
})(userName)
def deleteAccessToken(userName: String, accessTokenId: Int)(implicit s: Session): Unit =
db.run(
quote { (userName: String, accessTokenId: Int) =>
query[AccessToken].filter { t => t.userName == userName && t.accessTokenId == accessTokenId }.delete
}
)(List((userName, accessTokenId)))
db.run(quote { (userName: String, accessTokenId: Int) =>
query[AccessToken].filter { t => t.userName == userName && t.accessTokenId == accessTokenId }.delete
})(List((userName, accessTokenId)))
}

46
src/main/scala/gitbucket/core/service/AccountService.scala
View File

@@ -77,17 +77,15 @@ trait AccountService {
}
def getAccountByUserName(userName: String, includeRemoved: Boolean = false): Option[Account] = {
db.run(
quote { (userName: String, includeRemoved: Boolean) =>
query[Account].filter { t =>
if(includeRemoved){
t.userName == userName
} else {
t.userName == userName && t.removed == false
}
db.run(quote { (userName: String, includeRemoved: Boolean) =>
query[Account].filter { t =>
if(includeRemoved){
t.userName == userName
} else {
t.userName == userName && t.removed == false
}
}
)(userName, includeRemoved).headOption
})(userName, includeRemoved).headOption
}
@@ -97,26 +95,22 @@ trait AccountService {
if(needs.isEmpty){
map
} else {
map ++ db.run(
quote { (userNames: Set[String]) =>
map ++ db.run(quote { (userNames: Set[String]) =>
query[Account].filter { t => userNames.contains(t.userName) && t.removed == false }
}
)(userNames.toSet).map { a => a.userName -> a }.toMap
})(userNames.toSet).map { a => a.userName -> a }.toMap
}
}
def getAccountByMailAddress(mailAddress: String, includeRemoved: Boolean = false): Option[Account] = {
db.run(
quote { (mailAddress: String, includeRemoved: Boolean) =>
query[Account].filter { t =>
if(includeRemoved){
t.mailAddress.toLowerCase == mailAddress.toLowerCase
} else {
t.mailAddress.toLowerCase == mailAddress.toLowerCase && t.removed == false
}
db.run(quote { (mailAddress: String, includeRemoved: Boolean) =>
query[Account].filter { t =>
if(includeRemoved){
t.mailAddress.toLowerCase == mailAddress.toLowerCase
} else {
t.mailAddress.toLowerCase == mailAddress.toLowerCase && t.removed == false
}
}
)(mailAddress, includeRemoved).headOption
})(mailAddress, includeRemoved).headOption
}
def getAllUsers(includeRemoved: Boolean = true): List[Account] = {
@@ -210,14 +204,10 @@ trait AccountService {
}
def updateGroupMembers(groupName: String, members: List[(String, Boolean)]): Unit = {
db.run(
quote { (groupName: String) => query[GroupMember].filter(_.groupName == groupName).delete }
)(groupName)
db.run(quote { (groupName: String) => query[GroupMember].filter(_.groupName == groupName).delete })(groupName)
members.foreach { case (userName, isManager) =>
db.run(
quote { query[GroupMember].insert }
)(GroupMember(groupName, userName, isManager))
db.run(quote { query[GroupMember].insert })(GroupMember(groupName, userName, isManager))
}
}

169
src/main/scala/gitbucket/core/service/ActivityService.scala
View File

@@ -1,6 +1,6 @@
package gitbucket.core.service
import gitbucket.core.model.Activity
import gitbucket.core.model._
import gitbucket.core.model.Profile._
import gitbucket.core.util.JGitUtil
import profile.simple._
@@ -10,192 +10,185 @@ import io.getquill._
trait ActivityService {
def deleteOldActivities(limit: Int)(implicit s: Session): Int = {
db.run (
quote { (limit: Int) => query[Activity].map(_.activityId).sortBy(x => x)(Ord.desc).drop(limit) }
)(limit).headOption.map { activityId =>
def deleteOldActivities(limit: Int)(implicit s: Session): Int =
db.run (quote { (limit: Int) =>
query[Activity].map(_.activityId).sortBy(x => x)(Ord.desc).drop(limit)
})(limit).headOption.map { activityId =>
db.run (
quote { (activityId: Int) => query[Activity].filter(_.activityId <= activityId).delete }
)(activityId)
} getOrElse 0
}
def getActivitiesByUser(activityUserName: String, isPublic: Boolean)(implicit s: Session): List[Activity] =
Activities
.innerJoin(Repositories).on((t1, t2) => t1.byRepository(t2.userName, t2.repositoryName))
.filter { case (t1, t2) =>
if(isPublic){
(t1.activityUserName === activityUserName.bind) && (t2.isPrivate === false.bind)
} else {
(t1.activityUserName === activityUserName.bind)
db.run(quote { (activityUserName: String, isPublic: Boolean) =>
query[Activity].join(query[Repository]).on((a, r) => a.userName == r.userName && a.repositoryName == r.repositoryName)
.filter { case (a, r) =>
if(isPublic){
a.activityUserName == activityUserName
} else {
a.activityUserName == activityUserName && r.`private` == false
}
}
}
.sortBy { case (t1, t2) => t1.activityId desc }
.map { case (t1, t2) => t1 }
.take(30)
.list
.sortBy { case (a, r) => a.activityId }(Ord.desc)
.map { case (a, r) => a }
.take(30)
})(activityUserName, isPublic)
def getRecentActivities()(implicit s: Session): List[Activity] =
Activities
.innerJoin(Repositories).on((t1, t2) => t1.byRepository(t2.userName, t2.repositoryName))
.filter { case (t1, t2) => t2.isPrivate === false.bind }
.sortBy { case (t1, t2) => t1.activityId desc }
.map { case (t1, t2) => t1 }
.take(30)
.list
db.run(quote {
query[Activity].join(query[Repository]).on((a, r) => a.userName == r.userName && a.repositoryName == r.repositoryName)
.filter { case (a, r) => r.`private` == false}
.sortBy { case (a, r) => a.activityId }(Ord.desc)
.map { case (a, r) => a }
.take(30)
})
def getRecentActivitiesByOwners(owners : Set[String])(implicit s: Session): List[Activity] =
Activities
.innerJoin(Repositories).on((t1, t2) => t1.byRepository(t2.userName, t2.repositoryName))
.filter { case (t1, t2) => (t2.isPrivate === false.bind) || (t2.userName inSetBind owners) }
.sortBy { case (t1, t2) => t1.activityId desc }
.map { case (t1, t2) => t1 }
.take(30)
.list
db.run(quote { (owners: Set[String]) =>
query[Activity].join(query[Repository]).on((a, r) => a.userName == r.userName && a.repositoryName == r.repositoryName)
.filter { case (a, r) => r.`private` == false || owners.contains(r.userName) }
.sortBy { case (a, r) => a.activityId }(Ord.desc)
.map { case (a, r) => a }
.take(30)
})(owners)
def recordCreateRepositoryActivity(userName: String, repositoryName: String, activityUserName: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"create_repository",
s"[user:${activityUserName}] created [repo:${userName}/${repositoryName}]",
None,
currentDate)
None)
def recordCreateIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"open_issue",
s"[user:${activityUserName}] opened issue [issue:${userName}/${repositoryName}#${issueId}]",
Some(title),
currentDate)
Some(title))
def recordCloseIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"close_issue",
s"[user:${activityUserName}] closed issue [issue:${userName}/${repositoryName}#${issueId}]",
Some(title),
currentDate)
Some(title))
def recordClosePullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"close_issue",
s"[user:${activityUserName}] closed pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
Some(title),
currentDate)
Some(title))
def recordReopenIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"reopen_issue",
s"[user:${activityUserName}] reopened issue [issue:${userName}/${repositoryName}#${issueId}]",
Some(title),
currentDate)
Some(title))
def recordCommentIssueActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, comment: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"comment_issue",
s"[user:${activityUserName}] commented on issue [issue:${userName}/${repositoryName}#${issueId}]",
Some(cut(comment, 200)),
currentDate)
Some(cut(comment, 200)))
def recordCommentPullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, comment: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"comment_issue",
s"[user:${activityUserName}] commented on pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
Some(cut(comment, 200)),
currentDate)
Some(cut(comment, 200)))
def recordCommentCommitActivity(userName: String, repositoryName: String, activityUserName: String, commitId: String, comment: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"comment_commit",
s"[user:${activityUserName}] commented on commit [commit:${userName}/${repositoryName}@${commitId}]",
Some(cut(comment, 200)),
currentDate
)
Some(cut(comment, 200)))
def recordCreateWikiPageActivity(userName: String, repositoryName: String, activityUserName: String, pageName: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"create_wiki",
s"[user:${activityUserName}] created the [repo:${userName}/${repositoryName}] wiki",
Some(pageName),
currentDate)
Some(pageName))
def recordEditWikiPageActivity(userName: String, repositoryName: String, activityUserName: String, pageName: String, commitId: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"edit_wiki",
s"[user:${activityUserName}] edited the [repo:${userName}/${repositoryName}] wiki",
Some(pageName + ":" + commitId),
currentDate)
Some(pageName + ":" + commitId))
def recordPushActivity(userName: String, repositoryName: String, activityUserName: String,
branchName: String, commits: List[JGitUtil.CommitInfo])(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"push",
s"[user:${activityUserName}] pushed to [branch:${userName}/${repositoryName}#${branchName}] at [repo:${userName}/${repositoryName}]",
Some(commits.map { commit => commit.id + ":" + commit.shortMessage }.mkString("\n")),
currentDate)
Some(commits.map { commit => commit.id + ":" + commit.shortMessage }.mkString("\n")))
def recordCreateTagActivity(userName: String, repositoryName: String, activityUserName: String,
tagName: String, commits: List[JGitUtil.CommitInfo])(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"create_tag",
s"[user:${activityUserName}] created tag [tag:${userName}/${repositoryName}#${tagName}] at [repo:${userName}/${repositoryName}]",
None,
currentDate)
None)
def recordDeleteTagActivity(userName: String, repositoryName: String, activityUserName: String,
tagName: String, commits: List[JGitUtil.CommitInfo])(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"delete_tag",
s"[user:${activityUserName}] deleted tag ${tagName} at [repo:${userName}/${repositoryName}]",
None,
currentDate)
None)
def recordCreateBranchActivity(userName: String, repositoryName: String, activityUserName: String, branchName: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"create_branch",
s"[user:${activityUserName}] created branch [branch:${userName}/${repositoryName}#${branchName}] at [repo:${userName}/${repositoryName}]",
None,
currentDate)
None)
def recordDeleteBranchActivity(userName: String, repositoryName: String, activityUserName: String, branchName: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"delete_branch",
s"[user:${activityUserName}] deleted branch ${branchName} at [repo:${userName}/${repositoryName}]",
None,
currentDate)
None)
def recordForkActivity(userName: String, repositoryName: String, activityUserName: String, forkedUserName: String)(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
def recordForkActivity(userName: String, repositoryName: String, activityUserName: String, forkedUserName: String)(implicit s: Session): Unit =
insertActivity(userName, repositoryName, activityUserName,
"fork",
s"[user:${activityUserName}] forked [repo:${userName}/${repositoryName}] to [repo:${forkedUserName}/${repositoryName}]",
None,
currentDate)
None)
def recordPullRequestActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, title: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"open_pullreq",
s"[user:${activityUserName}] opened pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
Some(title),
currentDate)
Some(title))
def recordMergeActivity(userName: String, repositoryName: String, activityUserName: String, issueId: Int, message: String)
(implicit s: Session): Unit =
Activities insert Activity(userName, repositoryName, activityUserName,
insertActivity(userName, repositoryName, activityUserName,
"merge_pullreq",
s"[user:${activityUserName}] merged pull request [pullreq:${userName}/${repositoryName}#${issueId}]",
Some(message),
currentDate)
Some(message))
private def insertActivity(userName: String, repositoryName: String, activityUserName: String, activityType: String,
message: String, additionalInfo: Option[String]): Unit = {
db.run(quote { query[Activity].insert })(Activity(
userName = userName,
repositoryName = repositoryName,
activityUserName = activityUserName,
activityType = activityType,
message = message,
additionalInfo = additionalInfo,
activityDate = currentDate
))
}
private def cut(value: String, length: Int): String =
if(value.length > length) value.substring(0, length) + "..." else value

2
src/main/scala/gitbucket/core/service/RepositoryService.scala
View File

@@ -27,7 +27,7 @@ trait RepositoryService { self: AccountService =>
Repository(
userName = userName,
repositoryName = repositoryName,
isPrivate = isPrivate,
`private` = isPrivate,
description = description,
defaultBranch = "master",
registeredDate = currentDate,

4
src/main/scala/gitbucket/core/servlet/BasicAuthenticationFilter.scala
View File

@@ -76,14 +76,14 @@ class BasicAuthenticationFilter extends Filter with RepositoryService with Accou
case Array(_, repositoryOwner, repositoryName, _*) =>
getRepository(repositoryOwner, repositoryName.replaceFirst("\\.wiki\\.git$|\\.git$", "")) match {
case Some(repository) => {
if(!isUpdating && !repository.repository.isPrivate && settings.allowAnonymousAccess){
if(!isUpdating && !repository.repository.`private` && settings.allowAnonymousAccess){
chain.doFilter(request, response)
} else {
val passed = for {
auth <- Option(request.getHeader("Authorization"))
Array(username, password) = decodeAuthHeader(auth).split(":", 2)
account <- authenticate(settings, username, password)
} yield if(isUpdating || repository.repository.isPrivate){
} yield if(isUpdating || repository.repository.`private`){
if(hasWritePermission(repository.owner, repository.name, Some(account))){
request.setAttribute(Keys.Request.UserName, account.userName)
true

2
src/main/scala/gitbucket/core/ssh/GitCommand.scala
View File

@@ -92,7 +92,7 @@ class DefaultGitUploadPack(owner: String, repoName: String) extends DefaultGitCo
override protected def runTask(user: String)(implicit session: Session): Unit = {
getRepository(owner, repoName.replaceFirst("\\.wiki\\Z", "")).foreach { repositoryInfo =>
if(!repositoryInfo.repository.isPrivate || isWritableUser(user, repositoryInfo)){
if(!repositoryInfo.repository.`private` || isWritableUser(user, repositoryInfo)){
using(Git.open(getRepositoryDir(owner, repoName))) { git =>
val repository = git.getRepository
val upload = new UploadPack(repository)

4
src/main/scala/gitbucket/core/util/Authenticator.scala
View File

@@ -119,7 +119,7 @@ trait ReferrerAuthenticator { self: ControllerBase with RepositoryService =>
{
defining(request.paths){ paths =>
getRepository(paths(0), paths(1)).map { repository =>
if(!repository.repository.isPrivate){
if(!repository.repository.`private`){
action(repository)
} else {
context.loginAccount match {
@@ -148,7 +148,7 @@ trait ReadableUsersAuthenticator { self: ControllerBase with RepositoryService =
getRepository(paths(0), paths(1)).map { repository =>
context.loginAccount match {
case Some(x) if(x.administrator) => action(repository)
case Some(x) if(!repository.repository.isPrivate) => action(repository)
case Some(x) if(!repository.repository.`private`) => action(repository)
case Some(x) if(paths(0) == x.userName) => action(repository)
case Some(x) if(getCollaborators(paths(0), paths(1)).contains(x.userName)) => action(repository)
case _ => Unauthorized()

2
src/main/twirl/gitbucket/core/account/repositories.scala.html
View File

@@ -15,7 +15,7 @@
<div class="repository-content">
<div class="block-header">
<a href="@url(repository)">@repository.name</a>
@if(repository.repository.isPrivate){
@if(repository.repository.`private`){
<i class="octicon octicon-lock"></i>
}
</div>

2
src/main/twirl/gitbucket/core/helper/repositoryicon.scala.html
View File

@@ -2,7 +2,7 @@
@import gitbucket.core.service.RepositoryService
@import context._
@import gitbucket.core.view.helpers._
@if(repository.repository.isPrivate){
@if(repository.repository.`private`){
<i class="@{if(large){"mega-"}}octicon octicon-lock"></i>
} else {
@if(repository.repository.originUserName.isDefined){

2
src/main/twirl/gitbucket/core/main.scala.html
View File

@@ -36,7 +36,7 @@
<script src="@assets/vendors/facebox/facebox.js"></script>
<script src="@assets/vendors/jquery-hotkeys/jquery.hotkeys.js"></script>
@repository.map { repository =>
@if(!repository.repository.isPrivate){
@if(!repository.repository.`private`){
<meta name="go-import" content="@context.baseUrl.replaceFirst("^https?://", "")/@repository.owner/@repository.name git @repository.httpUrl" />
}
}

4
src/main/twirl/gitbucket/core/settings/options.scala.html
View File

@@ -21,7 +21,7 @@
<fieldset class="margin">
<label class="radio">
<input type="radio" name="isPrivate" value="false"
@if(!repository.repository.isPrivate ){ checked }
@if(!repository.repository.`private` ){ checked }
@if(repository.repository.parentUserName.isDefined){ disabled }
>
<span class="strong"><i class="octicon octicon-repo"></i> Public</span><br>
@@ -31,7 +31,7 @@
</label>
<label class="radio">
<input type="radio" name="isPrivate" value="true"
@if(repository.repository.isPrivate ){ checked }
@if(repository.repository.`private` ){ checked }
@if(repository.repository.parentUserName.isDefined){ disabled }
>
<span class="strong"><i class="octicon octicon-lock"></i> Private</span><br>