LightPIT: comparison src/main/kotlin/de/uapcore/lightpit/servlet/ProjectServlet.kt

-:c9c6abf167c7
+:37fbdcb422b7
 projectInfo.project,
 selectedVersion,
 selectedComponent
 )
-sealed class LookupResult<T> {
+private sealed interface LookupResult<T>
-class NotFound<T> : LookupResult<T>()
+private class NotFound<T> : LookupResult<T>
-data class Found<T>(val elem: T?) : LookupResult<T>()
+private data class Found<T>(val elem: T?) : LookupResult<T>
-}
 private fun <T : HasNode> HttpRequest.lookupPathParam(paramName: String, list: List<T>): LookupResult<T> {
 val node = pathParams[paramName]
 return if (node == null || node == "-") {
-LookupResult.Found(null)
+Found(null)
 } else {
 val result = list.find { it.node == node }
 if (result == null) {
-LookupResult.NotFound()
+NotFound()
 } else {
-LookupResult.Found(result)
+Found(result)
 }
 }
 }
 private fun obtainProjectInfo(http: HttpRequest, dao: DataAccessObject): ProjectInfo? {
 }
 }
 private fun feedPath(project: Project) = "feed/${project.node}/issues.rss"
-data class PathInfos(
+private data class PathInfos(
 val projectInfo: ProjectInfo,
 val version: Version?,
 val component: Component?
 ) {
 val project = projectInfo.project
 http.response.sendError(404)
 return null
 }
 val version = when (val result = http.lookupPathParam("version", projectInfo.versions)) {
-is LookupResult.NotFound -> {
+is NotFound -> {
 http.response.sendError(404)
 return null
 }
-is LookupResult.Found -> {
+is Found -> {
 result.elem
 }
 }
 val component = when (val result = http.lookupPathParam("component", projectInfo.components)) {
-is LookupResult.NotFound -> {
+is NotFound -> {
 http.response.sendError(404)
 return null
 }
-is LookupResult.Found -> {
+is Found -> {
 result.elem
 }
 }
 return PathInfos(projectInfo, version, component)
 http.styleSheets = listOf("projects")
 http.render("project-form")
 }
 private fun projectCommit(http: HttpRequest, dao: DataAccessObject) {
-// TODO: replace defaults with throwing validator exceptions
 val project = Project(http.param("id")?.toIntOrNull() ?: -1).apply {
 name = http.param("name") ?: ""
 node = http.param("node") ?: ""
 description = http.param("description") ?: ""
 ordinal = http.param("ordinal")?.toIntOrNull() ?: 0
 return
 }
 val version: Version
 when (val result = http.lookupPathParam("version", projectInfo.versions)) {
-is LookupResult.NotFound -> {
+is NotFound -> {
 http.response.sendError(404)
 return
 }
-is LookupResult.Found -> {
+is Found -> {
 version = result.elem ?: Version(-1, projectInfo.project.id)
 }
 }
 with(http) {
 styleSheets = listOf("projects")
 render("version-form")
 }
 }
-private fun versionCommit(http: HttpRequest, dao: DataAccessObject) {
+private fun obtainIdAndProject(http: HttpRequest, dao:DataAccessObject): Pair<Int, Project>? {
 val id = http.param("id")?.toIntOrNull()
 val projectid = http.param("projectid")?.toIntOrNull() ?: -1
 val project = dao.findProject(projectid)
-if (id == null || project == null) {
+return if (id == null || project == null) {
 http.response.sendError(400)
-return
+null
-}
+} else {
+Pair(id, project)
-// TODO: replace defaults with throwing validator exceptions
+}
-val version = Version(id, projectid).apply {
+}
+private fun versionCommit(http: HttpRequest, dao: DataAccessObject) {
+val idParams = obtainIdAndProject(http, dao) ?: return
+val (id, project) = idParams
+val version = Version(id, project.id).apply {
 name = http.param("name") ?: ""
 node = http.param("node") ?: ""
 ordinal = http.param("ordinal")?.toIntOrNull() ?: 0
 status = http.param("status")?.let(VersionStatus::valueOf) ?: VersionStatus.Future
 // intentional defaults
 return
 }
 val component: Component
 when (val result = http.lookupPathParam("component", projectInfo.components)) {
-is LookupResult.NotFound -> {
+is NotFound -> {
 http.response.sendError(404)
 return
 }
-is LookupResult.Found -> {
+is Found -> {
 component = result.elem ?: Component(-1, projectInfo.project.id)
 }
 }
 with(http) {
 render("component-form")
 }
 }
 private fun componentCommit(http: HttpRequest, dao: DataAccessObject) {
-val id = http.param("id")?.toIntOrNull()
+val idParams = obtainIdAndProject(http, dao) ?: return
-val projectid = http.param("projectid")?.toIntOrNull() ?: -1
+val (id, project) = idParams
-val project = dao.findProject(projectid)
-if (id == null || project == null) {
+val component = Component(id, project.id).apply {
-http.response.sendError(400)
-return
-}
-// TODO: replace defaults with throwing validator exceptions
-val component = Component(id, projectid).apply {
 name = http.param("name") ?: ""
 node = http.param("node") ?: ""
 ordinal = http.param("ordinal")?.toIntOrNull() ?: 0
 color = WebColor(http.param("color") ?: "#000000")
 description = http.param("description")
 if (issue == null) {
 http.response.sendError(404)
 return
 }
-// TODO: throw validator exception instead of using a default
 val commentId = http.param("commentid")?.toIntOrNull() ?: -1
 if (commentId > 0) {
 val comment = dao.findComment(commentId)
 val originalAuthor = comment?.author?.username
 if (originalAuthor != null && originalAuthor == http.remoteUser) {
 }
 }
 private fun issueCommit(http: HttpRequest, dao: DataAccessObject) {
 withPathInfo(http, dao)?.run {
-// TODO: throw validator exception instead of using defaults
 val issue = Issue(
 http.param("id")?.toIntOrNull() ?: -1,
 project
 ).apply {
 component = dao.findComponent(http.param("component")?.toIntOrNull() ?: -1)

Mercurial > hg > LightPIT / file comparison

comparison: src/main/kotlin/de/uapcore/lightpit/servlet/ProjectServlet.kt

src/main/kotlin/de/uapcore/lightpit/servlet/ProjectServlet.kt