Add special use case for determining if a BlogPost exists in both the cache and the server.

So if a blog is cached, and it does not exist on server, it will be deleted from the cache.

Author: mitchtabian

app/src/main/java/com/codingwithmitch/openapi/business/datasource/cache/blog/BlogPostDao.kt

@@ -12,6 +12,9 @@ interface BlogPostDao {
  @Delete
  suspend fun deleteBlogPost(blogPost: BlogPostEntity)
 
+ @Query("DELETE FROM blog_post WHERE pk = :pk")
+ suspend fun deleteBlogPost(pk: Int)
+
  @Query("""
  UPDATE blog_post SET title = :title, body = :body, image = :image 
  WHERE pk = :pk

app/src/main/java/com/codingwithmitch/openapi/business/datasource/network/main/OpenApiMainService.kt

@@ -73,6 +73,12 @@ interface OpenApiMainService {
  @Part("body") body: RequestBody,
  @Part image: MultipartBody.Part?
  ): BlogCreateUpdateResponse
+
+ @GET("blog/{slug}")
+ suspend fun getBlog(
+ @Header("Authorization") authorization: String,
+ @Path("slug") slug: String,
+ ): BlogPostDto?
 }
 
 

app/src/main/java/com/codingwithmitch/openapi/business/domain/util/ErrorHandling.kt

@@ -40,6 +40,7 @@ class ErrorHandling{
  const val ERROR_SOMETHING_WENT_WRONG = "Something went wrong."
  const val ERROR_DELETE_BLOG_DOES_NOT_EXIST = "That blog post does not exist."
  const val ERROR_DELETE_BLOG_NEED_PERMISSION = "You don't have permission to delete that."
+ const val ERROR_BLOG_DOES_NOT_EXIST = "That BlogPost does not exist on the server."
  const val INVALID_STATE_EVENT = "Invalid state event"
  const val CANNOT_BE_UNDONE = "This can't be undone."
  const val NETWORK_ERROR = "Network error"

app/src/main/java/com/codingwithmitch/openapi/business/domain/util/SuccessHandling.kt

@@ -13,6 +13,9 @@ class SuccessHandling {
  const val SUCCESS_BLOG_DELETED = "deleted"
  const val SUCCESS_BLOG_UPDATED = "updated"
 
+ const val SUCCESS_BLOG_DOES_NOT_EXIST_IN_CACHE = "Blog does not exist in the cache."
+ const val SUCCESS_BLOG_EXISTS_ON_SERVER = "Blog exists on the server and in the cache."
+
  const val SUCCESS_ACCOUNT_UPDATED = "Account update success"
  const val SUCCESS_PASSWORD_UPDATED = "successfully changed password"
 

app/src/main/java/com/codingwithmitch/openapi/business/interactors/blog/ConfirmBlogExistsOnServer.kt

@@ -0,0 +1,95 @@
+package com.codingwithmitch.openapi.business.interactors.blog
+
+import com.codingwithmitch.openapi.api.handleUseCaseException
+import com.codingwithmitch.openapi.business.datasource.cache.blog.BlogPostDao
+import com.codingwithmitch.openapi.business.datasource.cache.blog.toBlogPost
+import com.codingwithmitch.openapi.business.datasource.network.main.OpenApiMainService
+import com.codingwithmitch.openapi.business.domain.models.AuthToken
+import com.codingwithmitch.openapi.business.domain.models.BlogPost
+import com.codingwithmitch.openapi.business.domain.util.*
+import com.codingwithmitch.openapi.business.domain.util.SuccessHandling.Companion.SUCCESS_BLOG_DOES_NOT_EXIST_IN_CACHE
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.flow
+import java.lang.Exception
+
+/**
+ * If a blog exist in the cache but does not exist on server, we need to delete from cache.
+ */
+class ConfirmBlogExistsOnServer(
+ private val service: OpenApiMainService,
+ private val cache: BlogPostDao
+) {
+
+ fun execute(
+ authToken: AuthToken?,
+ pk: Int,
+ slug: String,
+ ): Flow<DataState<Response>> = flow {
+ emit(DataState.loading<Response>())
+ val cachedBlog = cache.getBlogPost(pk)
+ if(cachedBlog == null){
+ // It doesn't exist in cache. Finish.
+ emit(DataState.data<Response>(
+ response = Response(
+ message = SUCCESS_BLOG_DOES_NOT_EXIST_IN_CACHE,
+ uiComponentType = UIComponentType.None(),
+ messageType = MessageType.Success()
+ )
+ ))
+ }else{
+ if(authToken == null){
+ throw Exception(ErrorHandling.ERROR_AUTH_TOKEN_INVALID)
+ }
+ // confirm it exists on server
+ val blogPost = try {
+ service.getBlog(
+ authorization = "Token ${authToken.token}",
+ slug = slug,
+ )
+ }catch (e1: Exception){
+ e1.printStackTrace()
+ null
+ }
+ // if it exists on server but not in cache. Delete from cache and emit error.
+ if(blogPost == null){
+ cache.deleteBlogPost(pk)
+ emit(DataState.error<Response>(
+ response = Response(
+ message = ErrorHandling.ERROR_BLOG_DOES_NOT_EXIST,
+ uiComponentType = UIComponentType.Dialog(),
+ messageType = MessageType.Error()
+ )
+ ))
+ }else{ // if it exists in the cache and on the server. Everything is fine.
+ emit(DataState.data<Response>(
+ data = Response(
+ message = SuccessHandling.SUCCESS_BLOG_EXISTS_ON_SERVER,
+ uiComponentType = UIComponentType.None(),
+ messageType = MessageType.Success()
+ ),
+ response = null,
+ ))
+ }
+ }
+
+ }.catch { e ->
+ emit(handleUseCaseException(e))
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

app/src/main/java/com/codingwithmitch/openapi/di/blog/BlogModule.kt

@@ -73,6 +73,15 @@ object BlogModule {
  ): GetOrderAndFilter{
  return GetOrderAndFilter(appDataStoreManager)
  }
+
+ @Singleton
+ @Provides
+ fun provideConfirmBlogExistsOnServer(
+ service: OpenApiMainService,
+ cache: BlogPostDao,
+ ): ConfirmBlogExistsOnServer{
+ return ConfirmBlogExistsOnServer(service = service, cache = cache)
+ }
 }
 
 

app/src/main/java/com/codingwithmitch/openapi/presentation/main/blog/detail/ViewBlogEvents.kt

@@ -5,9 +5,14 @@ import com.codingwithmitch.openapi.business.domain.util.StateMessage
 
 sealed class ViewBlogEvents {
 
- data class isAuthor(val slug: String): ViewBlogEvents()
+ data class IsAuthor(val slug: String): ViewBlogEvents()
 
- data class getBlog(val pk: Int): ViewBlogEvents()
+ data class GetBlog(val pk: Int): ViewBlogEvents()
+
+ data class ConfirmBlogExistsOnServer(
+ val pk: Int,
+ val slug: String
+ ): ViewBlogEvents()
 
  object DeleteBlog: ViewBlogEvents()
 

app/src/main/java/com/codingwithmitch/openapi/presentation/main/blog/detail/ViewBlogFragment.kt

@@ -10,6 +10,7 @@ import com.bumptech.glide.request.RequestOptions
 import com.codingwithmitch.openapi.R
 import com.codingwithmitch.openapi.business.domain.models.BlogPost
 import com.codingwithmitch.openapi.business.domain.util.*
+import com.codingwithmitch.openapi.business.domain.util.ErrorHandling.Companion.ERROR_BLOG_DOES_NOT_EXIST
 import com.codingwithmitch.openapi.databinding.FragmentViewBlogBinding
 import com.codingwithmitch.openapi.presentation.main.blog.BaseBlogFragment
 import com.codingwithmitch.openapi.presentation.util.processQueue
@@ -50,14 +51,18 @@ class ViewBlogFragment : BaseBlogFragment()
 
  uiCommunicationListener.displayProgressBar(state.isLoading)
 
- processQueue(
- context = context,
- queue = state.queue,
- stateMessageCallback = object: StateMessageCallback {
- override fun removeMessageFromStack() {
- viewModel.onTriggerEvent(ViewBlogEvents.OnRemoveHeadFromQueue)
- }
- })
+ if(state.queue.peek()?.response?.message == ERROR_BLOG_DOES_NOT_EXIST){
+ findNavController().popBackStack(R.id.blogFragment, false)
+ }else{
+ processQueue(
+ context = context,
+ queue = state.queue,
+ stateMessageCallback = object: StateMessageCallback {
+ override fun removeMessageFromStack() {
+ viewModel.onTriggerEvent(ViewBlogEvents.OnRemoveHeadFromQueue)
+ }
+ })
+ }
 
  state.blogPost?.let { setBlogProperties(it) }
 

app/src/main/java/com/codingwithmitch/openapi/presentation/main/blog/detail/ViewBlogViewModel.kt

@@ -7,7 +7,9 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.codingwithmitch.openapi.business.domain.util.StateMessage
 import com.codingwithmitch.openapi.business.domain.util.SuccessHandling
+import com.codingwithmitch.openapi.business.domain.util.UIComponentType
 import com.codingwithmitch.openapi.business.domain.util.doesMessageAlreadyExistInQueue
+import com.codingwithmitch.openapi.business.interactors.blog.ConfirmBlogExistsOnServer
 import com.codingwithmitch.openapi.business.interactors.blog.DeleteBlogPost
 import com.codingwithmitch.openapi.business.interactors.blog.GetBlogFromCache
 import com.codingwithmitch.openapi.business.interactors.blog.IsAuthorOfBlogPost
@@ -23,6 +25,7 @@ class ViewBlogViewModel
 constructor(
  private val sessionManager: SessionManager,
  private val getBlogFromCache: GetBlogFromCache,
+ private val confirmBlogExistsOnServer: ConfirmBlogExistsOnServer,
  private val isAuthorOfBlogPost: IsAuthorOfBlogPost,
  private val deleteBlogPost: DeleteBlogPost,
  private val savedStateHandle: SavedStateHandle,
@@ -34,27 +37,42 @@ constructor(
 
  init {
  savedStateHandle.get<Int>("blogPostPk")?.let { blogPostPk ->
- onTriggerEvent(ViewBlogEvents.getBlog(blogPostPk))
+ onTriggerEvent(ViewBlogEvents.GetBlog(blogPostPk))
  }
  }
 
  fun onTriggerEvent(event: ViewBlogEvents){
  when(event){
- is ViewBlogEvents.getBlog -> {
+ is ViewBlogEvents.GetBlog -> {
  getBlog(
  event.pk,
+ object: OnCompleteCallback { // Determine if blog exists on server
+ override fun done() {
+ state.value?.let { state ->
+ state.blogPost?.let { blog ->
+ onTriggerEvent(ViewBlogEvents.ConfirmBlogExistsOnServer(pk = event.pk, blog.slug))
+ }
+ }
+ }
+ }
+ )
+ }
+ is ViewBlogEvents.ConfirmBlogExistsOnServer -> {
+ confirmBlogExistsOnServer(
+ event.pk,
+ event.slug,
  object: OnCompleteCallback { // Determine if they are the author
  override fun done() {
  state.value?.let { state ->
  state.blogPost?.let { blog ->
- onTriggerEvent(ViewBlogEvents.isAuthor(slug = blog.slug))
+ onTriggerEvent(ViewBlogEvents.IsAuthor(slug = blog.slug))
  }
  }
  }
  }
  )
  }
- is ViewBlogEvents.isAuthor -> {
+ is ViewBlogEvents.IsAuthor -> {
  isAuthor(event.slug)
  }
  is ViewBlogEvents.DeleteBlog -> {
@@ -94,12 +112,45 @@ constructor(
  state.value?.let { state ->
  val queue = state.queue
  if(!stateMessage.doesMessageAlreadyExistInQueue(queue = queue)){
- queue.add(stateMessage)
- this.state.value = state.copy(queue = queue)
+ if(!(stateMessage.response.uiComponentType is UIComponentType.None)){
+ queue.add(stateMessage)
+ this.state.value = state.copy(queue = queue)
+ }
  }
  }
  }
 
+ private fun confirmBlogExistsOnServer(pk: Int, slug: String, callback: OnCompleteCallback){
+ state.value?.let { state ->
+ confirmBlogExistsOnServer.execute(
+ authToken = sessionManager.state.value?.authToken,
+ pk = pk,
+ slug = slug,
+ ).onEach { dataState ->
+ this.state.value = state.copy(isLoading = dataState.isLoading)
+
+ dataState.data?.let { response ->
+ if(response.message == SuccessHandling.SUCCESS_BLOG_DOES_NOT_EXIST_IN_CACHE
+ || response.message == SuccessHandling.SUCCESS_BLOG_EXISTS_ON_SERVER
+ ){
+ // Blog exists in cache and on server. All is good.
+ callback.done()
+ }else{
+ appendToMessageQueue(
+ stateMessage = StateMessage(
+ response = response
+ )
+ )
+ }
+ }
+
+ dataState.stateMessage?.let { stateMessage ->
+ appendToMessageQueue(stateMessage)
+ }
+ }.launchIn(viewModelScope)
+ }
+ }
+
  private fun deleteBlog(){
  state.value?.let { state ->
  state.blogPost?.let { blogPost ->

app/src/test/java/com/codingwithmitch/openapi/datasource/network/blog/CreateResponses.kt

@@ -20,4 +20,18 @@ object CreateResponses {
  val dateUpdated = "2021-07-09T16:26:23.121544Z"
 
  val createSuccess = "{ \"response\": \"${SuccessHandling.SUCCESS_BLOG_CREATED}\", \"pk\": ${blogPk}, \"title\": \"${title}\", \"body\": \"${body}\", \"slug\": \"${slug}\", \"date_updated\": \"${dateUpdated}\", \"image\": \"${image}\", \"username\": \"${username}\" }"
-}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+