chore: rename impl file names w.r.t repos

sakethpathike · sakethpathike · commit d6f6ceb67e4c · 2025-03-07T20:51:43.000+05:30
diff --git a/src/main/kotlin/com/sakethh/linkora/data/repository/FoldersRepoImpl.kt b/src/main/kotlin/com/sakethh/linkora/data/repository/FoldersRepoImpl.kt
@@ -8,9 +8,8 @@ import com.sakethh.linkora.domain.dto.TimeStampBasedResponse
 import com.sakethh.linkora.domain.dto.folder.*
 import com.sakethh.linkora.domain.model.Folder
 import com.sakethh.linkora.domain.model.WebSocketEvent
-import com.sakethh.linkora.domain.repository.FoldersRepository
-import com.sakethh.linkora.domain.repository.LinksRepository
-import com.sakethh.linkora.domain.repository.PanelsRepository
+import com.sakethh.linkora.domain.repository.FoldersRepo
+import com.sakethh.linkora.domain.repository.PanelsRepo
 import com.sakethh.linkora.domain.tables.FoldersTable
 import com.sakethh.linkora.domain.tables.LinksTable
 import com.sakethh.linkora.domain.tables.PanelFoldersTable
@@ -24,7 +23,7 @@ import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.transactions.transaction
 import java.time.Instant
 
-class FoldersImplementation(private val panelsRepository: PanelsRepository) : FoldersRepository {
+class FoldersRepoImpl(private val panelsRepo: PanelsRepo) : FoldersRepo {
 
     override suspend fun createFolder(addFolderDTO: AddFolderDTO): Result<NewItemResponseDTO> {
         return try {
@@ -77,7 +76,7 @@ class FoldersImplementation(private val panelsRepository: PanelsRepository) : Fo
 
                 is Result.Success -> {
                     childFolders.response.map { it.id }.forEach { childFolderId ->
-                        panelsRepository.deleteAFolderFromAllPanels(
+                        panelsRepo.deleteAFolderFromAllPanels(
                             IDBasedDTO(
                                 id = childFolderId,
                                 correlation = idBasedDTO.correlation,
diff --git a/src/main/kotlin/com/sakethh/linkora/data/repository/LinksRepoImpl.kt b/src/main/kotlin/com/sakethh/linkora/data/repository/LinksRepoImpl.kt
@@ -8,7 +8,7 @@ import com.sakethh.linkora.domain.dto.NewItemResponseDTO
 import com.sakethh.linkora.domain.dto.TimeStampBasedResponse
 import com.sakethh.linkora.domain.dto.link.*
 import com.sakethh.linkora.domain.model.WebSocketEvent
-import com.sakethh.linkora.domain.repository.LinksRepository
+import com.sakethh.linkora.domain.repository.LinksRepo
 import com.sakethh.linkora.domain.tables.LinksTable
 import com.sakethh.linkora.domain.tables.LinksTable.lastModified
 import com.sakethh.linkora.domain.tables.TombstoneTable
@@ -23,7 +23,7 @@ import org.jetbrains.exposed.sql.SqlExpressionBuilder.inList
 import org.jetbrains.exposed.sql.transactions.transaction
 import java.time.Instant
 
-class LinksImplementation : LinksRepository {
+class LinksRepoImpl : LinksRepo {
     override suspend fun createANewLink(addLinkDTO: AddLinkDTO): Result<NewItemResponseDTO> {
         return try {
             val eventTimestamp = Instant.now().epochSecond
diff --git a/src/main/kotlin/com/sakethh/linkora/data/repository/MultiActionRepoImpl.kt b/src/main/kotlin/com/sakethh/linkora/data/repository/MultiActionRepoImpl.kt
@@ -8,8 +8,7 @@ import com.sakethh.linkora.domain.dto.ArchiveMultipleItemsDTO
 import com.sakethh.linkora.domain.dto.IDBasedDTO
 import com.sakethh.linkora.domain.dto.TimeStampBasedResponse
 import com.sakethh.linkora.domain.model.WebSocketEvent
-import com.sakethh.linkora.domain.repository.FoldersRepository
-import com.sakethh.linkora.domain.repository.LinksRepository
+import com.sakethh.linkora.domain.repository.FoldersRepo
 import com.sakethh.linkora.domain.repository.MultiActionRepo
 import com.sakethh.linkora.domain.tables.FoldersTable
 import com.sakethh.linkora.domain.tables.LinksTable
@@ -28,7 +27,7 @@ import org.jetbrains.exposed.sql.update
 import java.time.Instant
 
 class MultiActionRepoImpl(
-    private val foldersRepository: FoldersRepository
+    private val foldersRepo: FoldersRepo
 ) : MultiActionRepo {
     override suspend fun archiveMultipleItems(archiveMultipleItemsDTO: ArchiveMultipleItemsDTO): Result<TimeStampBasedResponse> {
         return try {
@@ -85,7 +84,7 @@ class MultiActionRepoImpl(
         val eventTimestamp = Instant.now().epochSecond
         return try {
             deleteMultipleItemsDTO.folderIds.forEach {
-                foldersRepository.deleteFolder(
+                foldersRepo.deleteFolder(
                     IDBasedDTO(
                         id = it,
                         correlation = deleteMultipleItemsDTO.correlation,
diff --git a/src/main/kotlin/com/sakethh/linkora/data/repository/PanelsRepoImpl.kt b/src/main/kotlin/com/sakethh/linkora/data/repository/PanelsRepoImpl.kt
@@ -7,7 +7,7 @@ import com.sakethh.linkora.domain.dto.NewItemResponseDTO
 import com.sakethh.linkora.domain.dto.TimeStampBasedResponse
 import com.sakethh.linkora.domain.dto.panel.*
 import com.sakethh.linkora.domain.model.WebSocketEvent
-import com.sakethh.linkora.domain.repository.PanelsRepository
+import com.sakethh.linkora.domain.repository.PanelsRepo
 import com.sakethh.linkora.domain.tables.PanelFoldersTable
 import com.sakethh.linkora.domain.tables.PanelsTable
 import com.sakethh.linkora.domain.tables.helper.TombStoneHelper
@@ -23,7 +23,7 @@ import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
 import java.time.Instant
 
-class PanelsRepoImpl : PanelsRepository {
+class PanelsRepoImpl : PanelsRepo {
 
     override suspend fun addANewPanel(addANewPanelDTO: AddANewPanelDTO): Result<NewItemResponseDTO> {
         return try {
diff --git a/src/main/kotlin/com/sakethh/linkora/domain/repository/FoldersRepo.kt b/src/main/kotlin/com/sakethh/linkora/domain/repository/FoldersRepo.kt
@@ -7,7 +7,7 @@ import com.sakethh.linkora.domain.dto.folder.*
 import com.sakethh.linkora.domain.model.Folder
 import com.sakethh.linkora.domain.Result
 
-interface FoldersRepository {
+interface FoldersRepo {
     suspend fun createFolder(addFolderDTO: AddFolderDTO): Result<NewItemResponseDTO>
     suspend fun deleteFolder(idBasedDTO: IDBasedDTO): Result<TimeStampBasedResponse>
     suspend fun getChildFolders(idBasedDTO: IDBasedDTO): Result<List<Folder>>
diff --git a/src/main/kotlin/com/sakethh/linkora/domain/repository/LinksRepo.kt b/src/main/kotlin/com/sakethh/linkora/domain/repository/LinksRepo.kt
@@ -6,7 +6,7 @@ import com.sakethh.linkora.domain.dto.NewItemResponseDTO
 import com.sakethh.linkora.domain.dto.TimeStampBasedResponse
 import com.sakethh.linkora.domain.dto.link.*
 
-interface LinksRepository {
+interface LinksRepo {
     suspend fun createANewLink(addLinkDTO: AddLinkDTO): Result<NewItemResponseDTO>
     suspend fun deleteALink(idBasedDTO: IDBasedDTO): Result<TimeStampBasedResponse>
     suspend fun updateLinkedFolderIdOfALink(updateLinkedFolderIDDto: UpdateLinkedFolderIDDto): Result<TimeStampBasedResponse>
diff --git a/src/main/kotlin/com/sakethh/linkora/domain/repository/PanelsRepo.kt b/src/main/kotlin/com/sakethh/linkora/domain/repository/PanelsRepo.kt
@@ -9,7 +9,7 @@ import com.sakethh.linkora.domain.dto.panel.DeleteAFolderFromAPanelDTO
 import com.sakethh.linkora.domain.dto.panel.UpdatePanelNameDTO
 import com.sakethh.linkora.domain.Result
 
-interface PanelsRepository {
+interface PanelsRepo {
     suspend fun addANewPanel(addANewPanelDTO: AddANewPanelDTO): Result<NewItemResponseDTO>
     suspend fun addANewFolderInAPanel(addANewPanelFolderDTO: AddANewPanelFolderDTO): Result<NewItemResponseDTO>
     suspend fun deleteAPanel(idBasedDTO: IDBasedDTO): Result<TimeStampBasedResponse>
diff --git a/src/main/kotlin/com/sakethh/linkora/presentation/routing/Routing.kt b/src/main/kotlin/com/sakethh/linkora/presentation/routing/Routing.kt
@@ -47,14 +47,14 @@ fun Application.configureRouting(serverConfig: ServerConfig, markdownManagerRepo
             call.respondText(contentType = ContentType.Text.Html, text = requiredHtml)
         }
     }
-    val linksRepository: LinksRepository = LinksImplementation()
-    val panelsRepository: PanelsRepository = PanelsRepoImpl()
-    val foldersRepository: FoldersRepository = FoldersImplementation(panelsRepository)
-    val tombstoneRouting: SyncRepo = SyncRepoImpl()
-    val multiActionRepo: MultiActionRepo = MultiActionRepoImpl(foldersRepository)
-    foldersRouting(foldersRepository)
-    linksRouting(linksRepository)
-    panelsRouting(panelsRepository)
-    syncRouting(tombstoneRouting)
+    val linksRepo: LinksRepo = LinksRepoImpl()
+    val panelsRepo: PanelsRepo = PanelsRepoImpl()
+    val foldersRepo: FoldersRepo = FoldersRepoImpl(panelsRepo)
+    val syncRepo: SyncRepo = SyncRepoImpl()
+    val multiActionRepo: MultiActionRepo = MultiActionRepoImpl(foldersRepo)
+    foldersRouting(foldersRepo)
+    linksRouting(linksRepo)
+    panelsRouting(panelsRepo)
+    syncRouting(syncRepo)
     multiActionRouting(multiActionRepo)
 }
diff --git a/src/main/kotlin/com/sakethh/linkora/presentation/routing/http/FoldersRouting.kt b/src/main/kotlin/com/sakethh/linkora/presentation/routing/http/FoldersRouting.kt
@@ -4,61 +4,61 @@ import com.sakethh.linkora.Security
 import com.sakethh.linkora.domain.Route
 import com.sakethh.linkora.domain.dto.IDBasedDTO
 import com.sakethh.linkora.domain.dto.folder.*
-import com.sakethh.linkora.domain.repository.FoldersRepository
+import com.sakethh.linkora.domain.repository.FoldersRepo
 import com.sakethh.linkora.utils.respondWithResult
 import io.ktor.server.application.*
 import io.ktor.server.auth.*
 import io.ktor.server.routing.*
 
-fun Application.foldersRouting(foldersRepository: FoldersRepository) {
+fun Application.foldersRouting(foldersRepo: FoldersRepo) {
     routing {
         authenticate(Security.BEARER.name) {
             post<AddFolderDTO>(Route.Folder.CREATE_FOLDER.name) { folderDTO ->
-                respondWithResult(foldersRepository.createFolder(folderDTO))
+                respondWithResult(foldersRepo.createFolder(folderDTO))
             }
 
             post<IDBasedDTO>(Route.Folder.DELETE_FOLDER.name) {
-                respondWithResult(foldersRepository.deleteFolder(it))
+                respondWithResult(foldersRepo.deleteFolder(it))
             }
 
             post<IDBasedDTO>(Route.Folder.GET_CHILD_FOLDERS.name) {
-                respondWithResult(foldersRepository.getChildFolders(it))
+                respondWithResult(foldersRepo.getChildFolders(it))
             }
 
             get(Route.Folder.GET_ROOT_FOLDERS.name) {
-                respondWithResult(foldersRepository.getRootFolders())
+                respondWithResult(foldersRepo.getRootFolders())
             }
 
             post<IDBasedDTO>(Route.Folder.MARK_FOLDER_AS_ARCHIVE.name) {
-                respondWithResult(foldersRepository.markAsArchive(it))
+                respondWithResult(foldersRepo.markAsArchive(it))
             }
 
             post<IDBasedDTO>(Route.Folder.MARK_AS_REGULAR_FOLDER.name) {
-                respondWithResult(foldersRepository.markAsRegularFolder(it))
+                respondWithResult(foldersRepo.markAsRegularFolder(it))
             }
 
             post<MoveFoldersDTO>(Route.Folder.MOVE_FOLDERS.name) {
                 respondWithResult(
-                    foldersRepository.moveFolders(it)
+                    foldersRepo.moveFolders(it)
                 )
             }
 
             post<UpdateFolderNameDTO>(Route.Folder.UPDATE_FOLDER_NAME.name) {
                 respondWithResult(
-                    foldersRepository.updateFolderName(it)
+                    foldersRepo.updateFolderName(it)
                 )
             }
 
             post<UpdateFolderNoteDTO>(Route.Folder.UPDATE_FOLDER_NOTE.name) {
-                respondWithResult(foldersRepository.updateFolderNote(it))
+                respondWithResult(foldersRepo.updateFolderNote(it))
             }
 
             post<IDBasedDTO>(Route.Folder.DELETE_FOLDER_NOTE.name) {
-                respondWithResult(foldersRepository.deleteFolderNote(it))
+                respondWithResult(foldersRepo.deleteFolderNote(it))
             }
 
             post<MarkSelectedFoldersAsRootDTO>(Route.Folder.MARK_FOLDERS_AS_ROOT.name) {
-                respondWithResult(foldersRepository.markSelectedFoldersAsRoot(it))
+                respondWithResult(foldersRepo.markSelectedFoldersAsRoot(it))
             }
         }
     }
diff --git a/src/main/kotlin/com/sakethh/linkora/presentation/routing/http/LinksRouting.kt b/src/main/kotlin/com/sakethh/linkora/presentation/routing/http/LinksRouting.kt
@@ -4,69 +4,69 @@ import com.sakethh.linkora.Security
 import com.sakethh.linkora.domain.Route
 import com.sakethh.linkora.domain.dto.IDBasedDTO
 import com.sakethh.linkora.domain.dto.link.*
-import com.sakethh.linkora.domain.repository.LinksRepository
+import com.sakethh.linkora.domain.repository.LinksRepo
 import com.sakethh.linkora.utils.respondWithResult
 import io.ktor.server.application.*
 import io.ktor.server.auth.*
 import io.ktor.server.routing.*
 
-fun Application.linksRouting(linksRepository: LinksRepository) {
+fun Application.linksRouting(linksRepo: LinksRepo) {
     routing {
         authenticate(Security.BEARER.name) {
             post<AddLinkDTO>(Route.Link.CREATE_A_NEW_LINK.name) {
-                respondWithResult(linksRepository.createANewLink(it))
+                respondWithResult(linksRepo.createANewLink(it))
             }
 
             post<IDBasedDTO>(Route.Link.DELETE_A_LINK.name) {
-                respondWithResult(linksRepository.deleteALink(it))
+                respondWithResult(linksRepo.deleteALink(it))
             }
 
             post<UpdateLinkedFolderIDDto>(Route.Link.UPDATE_LINKED_FOLDER_ID.name) {
                 respondWithResult(
-                    linksRepository.updateLinkedFolderIdOfALink(it)
+                    linksRepo.updateLinkedFolderIdOfALink(it)
                 )
             }
 
             post<UpdateTitleOfTheLinkDTO>(Route.Link.UPDATE_LINK_TITLE.name) {
                 respondWithResult(
-                    linksRepository.updateTitleOfTheLink(it)
+                    linksRepo.updateTitleOfTheLink(it)
                 )
             }
 
             post<UpdateNoteOfALinkDTO>(Route.Link.UPDATE_LINK_NOTE.name) {
                 respondWithResult(
-                    linksRepository.updateNote(it)
+                    linksRepo.updateNote(it)
                 )
             }
 
             post<UpdateLinkUserAgentDTO>(Route.Link.UPDATE_USER_AGENT.name) {
                 respondWithResult(
-                    linksRepository.updateUserAgent(it)
+                    linksRepo.updateUserAgent(it)
                 )
             }
 
             post<IDBasedDTO>(Route.Link.ARCHIVE_LINK.name) {
-                respondWithResult(linksRepository.archiveALink(it))
+                respondWithResult(linksRepo.archiveALink(it))
             }
 
             post<IDBasedDTO>(Route.Link.UNARCHIVE_LINK.name) {
-                respondWithResult(linksRepository.unArchiveALink(it))
+                respondWithResult(linksRepo.unArchiveALink(it))
             }
 
             post<IDBasedDTO>(Route.Link.MARK_AS_IMP.name) {
-                respondWithResult(linksRepository.markALinkAsImp(it))
+                respondWithResult(linksRepo.markALinkAsImp(it))
             }
 
             post<IDBasedDTO>(Route.Link.UNMARK_AS_IMP.name) {
-                respondWithResult(linksRepository.markALinkAsNonImp(it))
+                respondWithResult(linksRepo.markALinkAsNonImp(it))
             }
 
             post<LinkDTO>(Route.Link.UPDATE_LINK.name) {
-                respondWithResult(linksRepository.updateLink(it))
+                respondWithResult(linksRepo.updateLink(it))
             }
 
             post<DeleteDuplicateLinksDTO>(Route.Link.DELETE_DUPLICATE_LINKS.name) {
-                respondWithResult(linksRepository.deleteDuplicateLinks(it))
+                respondWithResult(linksRepo.deleteDuplicateLinks(it))
             }
         }
     }
diff --git a/src/main/kotlin/com/sakethh/linkora/presentation/routing/http/PanelsRouting.kt b/src/main/kotlin/com/sakethh/linkora/presentation/routing/http/PanelsRouting.kt
@@ -6,42 +6,42 @@ import com.sakethh.linkora.domain.dto.panel.AddANewPanelDTO
 import com.sakethh.linkora.domain.dto.panel.AddANewPanelFolderDTO
 import com.sakethh.linkora.domain.dto.panel.DeleteAFolderFromAPanelDTO
 import com.sakethh.linkora.domain.dto.panel.UpdatePanelNameDTO
-import com.sakethh.linkora.domain.repository.PanelsRepository
+import com.sakethh.linkora.domain.repository.PanelsRepo
 import com.sakethh.linkora.utils.respondWithResult
 import io.ktor.server.application.*
 import io.ktor.server.auth.*
 import io.ktor.server.routing.*
 import com.sakethh.linkora.domain.Route
 
-fun Application.panelsRouting(panelsRepository: PanelsRepository) {
+fun Application.panelsRouting(panelsRepo: PanelsRepo) {
     routing {
         authenticate(Security.BEARER.name) {
             post<AddANewPanelDTO>(Route.Panel.ADD_A_NEW_PANEL.name) {
-                respondWithResult(panelsRepository.addANewPanel(it))
+                respondWithResult(panelsRepo.addANewPanel(it))
             }
 
             post<AddANewPanelFolderDTO>(Route.Panel.ADD_A_NEW_FOLDER_IN_A_PANEL.name) {
-                respondWithResult(panelsRepository.addANewFolderInAPanel(it))
+                respondWithResult(panelsRepo.addANewFolderInAPanel(it))
             }
 
             post<IDBasedDTO>(Route.Panel.DELETE_A_PANEL.name) {
-                respondWithResult(panelsRepository.deleteAPanel(it))
+                respondWithResult(panelsRepo.deleteAPanel(it))
             }
 
             post<UpdatePanelNameDTO>(Route.Panel.UPDATE_A_PANEL_NAME.name) {
-                respondWithResult(panelsRepository.updateAPanelName(it))
+                respondWithResult(panelsRepo.updateAPanelName(it))
             }
 
             post<IDBasedDTO>(Route.Panel.DELETE_A_FOLDER_FROM_ALL_PANELS.name) {
-                respondWithResult(panelsRepository.deleteAFolderFromAllPanels(it))
+                respondWithResult(panelsRepo.deleteAFolderFromAllPanels(it))
             }
 
             post<DeleteAFolderFromAPanelDTO>(Route.Panel.DELETE_A_FOLDER_FROM_A_PANEL.name) {
-                respondWithResult(panelsRepository.deleteAFolderFromAPanel(it))
+                respondWithResult(panelsRepo.deleteAFolderFromAPanel(it))
             }
 
             post<IDBasedDTO>(Route.Panel.DELETE_ALL_FOLDERS_FROM_A_PANEL.name) {
-                respondWithResult(panelsRepository.deleteAllFoldersFromAPanel(it))
+                respondWithResult(panelsRepo.deleteAllFoldersFromAPanel(it))
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -4,61 +4,61 @@ import com.sakethh.linkora.Security`
`4`	`4`	`import com.sakethh.linkora.domain.Route`
`5`	`5`	`import com.sakethh.linkora.domain.dto.IDBasedDTO`
`6`	`6`	`import com.sakethh.linkora.domain.dto.folder.*`
`7`		`-import com.sakethh.linkora.domain.repository.FoldersRepository`
	`7`	`+import com.sakethh.linkora.domain.repository.FoldersRepo`
`8`	`8`	`import com.sakethh.linkora.utils.respondWithResult`
`9`	`9`	`import io.ktor.server.application.*`
`10`	`10`	`import io.ktor.server.auth.*`
`11`	`11`	`import io.ktor.server.routing.*`
`12`	`12`
`13`		`-fun Application.foldersRouting(foldersRepository: FoldersRepository) {`
	`13`	`+fun Application.foldersRouting(foldersRepo: FoldersRepo) {`
`14`	`14`	`routing {`
`15`	`15`	`authenticate(Security.BEARER.name) {`
`16`	`16`	`post<AddFolderDTO>(Route.Folder.CREATE_FOLDER.name) { folderDTO ->`
`17`		`- respondWithResult(foldersRepository.createFolder(folderDTO))`
	`17`	`+ respondWithResult(foldersRepo.createFolder(folderDTO))`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`post<IDBasedDTO>(Route.Folder.DELETE_FOLDER.name) {`
`21`		`- respondWithResult(foldersRepository.deleteFolder(it))`
	`21`	`+ respondWithResult(foldersRepo.deleteFolder(it))`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`post<IDBasedDTO>(Route.Folder.GET_CHILD_FOLDERS.name) {`
`25`		`- respondWithResult(foldersRepository.getChildFolders(it))`
	`25`	`+ respondWithResult(foldersRepo.getChildFolders(it))`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`get(Route.Folder.GET_ROOT_FOLDERS.name) {`
`29`		`- respondWithResult(foldersRepository.getRootFolders())`
	`29`	`+ respondWithResult(foldersRepo.getRootFolders())`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`post<IDBasedDTO>(Route.Folder.MARK_FOLDER_AS_ARCHIVE.name) {`
`33`		`- respondWithResult(foldersRepository.markAsArchive(it))`
	`33`	`+ respondWithResult(foldersRepo.markAsArchive(it))`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`post<IDBasedDTO>(Route.Folder.MARK_AS_REGULAR_FOLDER.name) {`
`37`		`- respondWithResult(foldersRepository.markAsRegularFolder(it))`
	`37`	`+ respondWithResult(foldersRepo.markAsRegularFolder(it))`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`post<MoveFoldersDTO>(Route.Folder.MOVE_FOLDERS.name) {`
`41`	`41`	`respondWithResult(`
`42`		`- foldersRepository.moveFolders(it)`
	`42`	`+ foldersRepo.moveFolders(it)`
`43`	`43`	`)`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`post<UpdateFolderNameDTO>(Route.Folder.UPDATE_FOLDER_NAME.name) {`
`47`	`47`	`respondWithResult(`
`48`		`- foldersRepository.updateFolderName(it)`
	`48`	`+ foldersRepo.updateFolderName(it)`
`49`	`49`	`)`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`post<UpdateFolderNoteDTO>(Route.Folder.UPDATE_FOLDER_NOTE.name) {`
`53`		`- respondWithResult(foldersRepository.updateFolderNote(it))`
	`53`	`+ respondWithResult(foldersRepo.updateFolderNote(it))`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`post<IDBasedDTO>(Route.Folder.DELETE_FOLDER_NOTE.name) {`
`57`		`- respondWithResult(foldersRepository.deleteFolderNote(it))`
	`57`	`+ respondWithResult(foldersRepo.deleteFolderNote(it))`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`post<MarkSelectedFoldersAsRootDTO>(Route.Folder.MARK_FOLDERS_AS_ROOT.name) {`
`61`		`- respondWithResult(foldersRepository.markSelectedFoldersAsRoot(it))`
	`61`	`+ respondWithResult(foldersRepo.markSelectedFoldersAsRoot(it))`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,69 +4,69 @@ import com.sakethh.linkora.Security`
`4`	`4`	`import com.sakethh.linkora.domain.Route`
`5`	`5`	`import com.sakethh.linkora.domain.dto.IDBasedDTO`
`6`	`6`	`import com.sakethh.linkora.domain.dto.link.*`
`7`		`-import com.sakethh.linkora.domain.repository.LinksRepository`
	`7`	`+import com.sakethh.linkora.domain.repository.LinksRepo`
`8`	`8`	`import com.sakethh.linkora.utils.respondWithResult`
`9`	`9`	`import io.ktor.server.application.*`
`10`	`10`	`import io.ktor.server.auth.*`
`11`	`11`	`import io.ktor.server.routing.*`
`12`	`12`
`13`		`-fun Application.linksRouting(linksRepository: LinksRepository) {`
	`13`	`+fun Application.linksRouting(linksRepo: LinksRepo) {`
`14`	`14`	`routing {`
`15`	`15`	`authenticate(Security.BEARER.name) {`
`16`	`16`	`post<AddLinkDTO>(Route.Link.CREATE_A_NEW_LINK.name) {`
`17`		`- respondWithResult(linksRepository.createANewLink(it))`
	`17`	`+ respondWithResult(linksRepo.createANewLink(it))`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`post<IDBasedDTO>(Route.Link.DELETE_A_LINK.name) {`
`21`		`- respondWithResult(linksRepository.deleteALink(it))`
	`21`	`+ respondWithResult(linksRepo.deleteALink(it))`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`post<UpdateLinkedFolderIDDto>(Route.Link.UPDATE_LINKED_FOLDER_ID.name) {`
`25`	`25`	`respondWithResult(`
`26`		`- linksRepository.updateLinkedFolderIdOfALink(it)`
	`26`	`+ linksRepo.updateLinkedFolderIdOfALink(it)`
`27`	`27`	`)`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`post<UpdateTitleOfTheLinkDTO>(Route.Link.UPDATE_LINK_TITLE.name) {`
`31`	`31`	`respondWithResult(`
`32`		`- linksRepository.updateTitleOfTheLink(it)`
	`32`	`+ linksRepo.updateTitleOfTheLink(it)`
`33`	`33`	`)`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`post<UpdateNoteOfALinkDTO>(Route.Link.UPDATE_LINK_NOTE.name) {`
`37`	`37`	`respondWithResult(`
`38`		`- linksRepository.updateNote(it)`
	`38`	`+ linksRepo.updateNote(it)`
`39`	`39`	`)`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`post<UpdateLinkUserAgentDTO>(Route.Link.UPDATE_USER_AGENT.name) {`
`43`	`43`	`respondWithResult(`
`44`		`- linksRepository.updateUserAgent(it)`
	`44`	`+ linksRepo.updateUserAgent(it)`
`45`	`45`	`)`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`post<IDBasedDTO>(Route.Link.ARCHIVE_LINK.name) {`
`49`		`- respondWithResult(linksRepository.archiveALink(it))`
	`49`	`+ respondWithResult(linksRepo.archiveALink(it))`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`post<IDBasedDTO>(Route.Link.UNARCHIVE_LINK.name) {`
`53`		`- respondWithResult(linksRepository.unArchiveALink(it))`
	`53`	`+ respondWithResult(linksRepo.unArchiveALink(it))`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`post<IDBasedDTO>(Route.Link.MARK_AS_IMP.name) {`
`57`		`- respondWithResult(linksRepository.markALinkAsImp(it))`
	`57`	`+ respondWithResult(linksRepo.markALinkAsImp(it))`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`post<IDBasedDTO>(Route.Link.UNMARK_AS_IMP.name) {`
`61`		`- respondWithResult(linksRepository.markALinkAsNonImp(it))`
	`61`	`+ respondWithResult(linksRepo.markALinkAsNonImp(it))`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`post<LinkDTO>(Route.Link.UPDATE_LINK.name) {`
`65`		`- respondWithResult(linksRepository.updateLink(it))`
	`65`	`+ respondWithResult(linksRepo.updateLink(it))`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`post<DeleteDuplicateLinksDTO>(Route.Link.DELETE_DUPLICATE_LINKS.name) {`
`69`		`- respondWithResult(linksRepository.deleteDuplicateLinks(it))`
	`69`	`+ respondWithResult(linksRepo.deleteDuplicateLinks(it))`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`}`