fix(@desktop/wallet): fix how collectibles are shown after an error, …

…according to the design

Part of #10063

src/app/boot/app_controller.nim

@@ -180,7 +180,7 @@ proc newAppController*(statusFoundation: StatusFoundation): AppController =
   result.collectibleService = collectible_service.newService(statusFoundation.events, statusFoundation.threadpool, result.networkService)
   result.walletAccountService = wallet_account_service.newService(
     statusFoundation.events, statusFoundation.threadpool, result.settingsService, result.accountsService,
-    result.tokenService, result.networkService, result.collectibleService
+    result.tokenService, result.networkService
   )
   result.messageService = message_service.newService(
     statusFoundation.events, statusFoundation.threadpool, result.contactsService, result.tokenService, result.walletAccountService, result.networkService

src/app/modules/main/wallet_section/collectibles/controller.nim

@@ -18,7 +18,7 @@ type
     networkConnectionService: network_connection_service.Service
 
   # Forward declaration
-proc resetOwnedCollectibles*(self: Controller, chainId: int, address: string)
+proc refetchOwnedCollectibles*(self: Controller, chainId: int, address: string)
 
 proc newController*(
   delegate: io_interface.AccessInterface,
@@ -45,36 +45,29 @@ proc resetCollectibles(self: Controller, chainId: int, address: string) =
   let data = self.collectibleService.getOwnedCollectibles(chainId, address)
   self.delegate.setCollectibles(chainId, address, data)
 
-proc processNewCollectibles(self: Controller, chainId: int, address: string) =
+proc updateCollectibles(self: Controller, chainId: int, address: string) =
   let data = self.collectibleService.getOwnedCollectibles(chainId, address)
   self.delegate.appendCollectibles(chainId, address, data)
 
-  if not self.nodeService.isConnected() or not self.networkConnectionService.checkIfConnected(COLLECTIBLES):
-    self.delegate.connectionToOpenSea(false)
-
 proc init*(self: Controller) =  
-  self.events.on(SIGNAL_OWNED_COLLECTIBLES_RESET) do(e:Args):
+  self.events.on(SIGNAL_OWNED_COLLECTIBLES_REFETCH) do(e:Args):
     let args = OwnedCollectiblesUpdateArgs(e)
     self.resetCollectibles(args.chainId, args.address)
 
+  self.events.on(SIGNAL_OWNED_COLLECTIBLES_UPDATE_ERROR) do(e:Args):
+    let args = OwnedCollectiblesUpdateArgs(e)
+    self.updateCollectibles(args.chainId, args.address)
+
   self.events.on(SIGNAL_OWNED_COLLECTIBLES_UPDATE_STARTED) do(e:Args):
     let args = OwnedCollectiblesUpdateArgs(e)
     self.delegate.onFetchStarted(args.chainId, args.address)
 
   self.events.on(SIGNAL_OWNED_COLLECTIBLES_UPDATE_FINISHED) do(e:Args):
     let args = OwnedCollectiblesUpdateArgs(e)
-    self.processNewCollectibles(args.chainId, args.address)
+    self.updateCollectibles(args.chainId, args.address)
 
   self.events.on(SIGNAL_REFRESH_COLLECTIBLES) do(e:Args):
-    self.collectibleService.resetAllOwnedCollectibles()
-
-  self.events.on(SIGNAL_NETWORK_DISCONNECTED) do(e: Args):
-    self.delegate.connectionToOpenSea(false)
-
-  self.events.on(SIGNAL_CONNECTION_UPDATE) do(e:Args):
-    let args = NetworkConnectionsArgs(e)
-    if args.website == COLLECTIBLES:
-      self.delegate.connectionToOpenSea(not args.completelyDown)
+    self.collectibleService.refetchAllOwnedCollectibles()
 
 proc getWalletAccount*(self: Controller, accountIndex: int): wallet_account_service.WalletAccountDto =
   return self.walletAccountService.getWalletAccount(accountIndex)
@@ -85,8 +78,8 @@ proc getNetwork*(self: Controller): network_service.NetworkDto =
 proc getOwnedCollectibles*(self: Controller, chainId: int, address: string): CollectiblesData =
   return self.collectibleService.getOwnedCollectibles(chainId, address)
 
-proc resetOwnedCollectibles*(self: Controller, chainId: int, address: string) =
-  self.collectibleService.resetOwnedCollectibles(chainId, address)
+proc refetchOwnedCollectibles*(self: Controller, chainId: int, address: string) =
+  self.collectibleService.refetchOwnedCollectibles(chainId, address)
 
 proc fetchOwnedCollectibles*(self: Controller, chainId: int, address: string) =
   self.collectibleService.fetchOwnedCollectibles(chainId, address)

src/app/modules/main/wallet_section/collectibles/io_interface.nim

@@ -37,6 +37,3 @@ method collectiblesModuleDidLoad*(self: AccessInterface) {.base.} =
 
 method currentCollectibleModuleDidLoad*(self: AccessInterface) {.base.} =
   raise newException(ValueError, "No implementation available")
-
-method connectionToOpenSea*(self: AccessInterface, connected: bool) {.base.} =
-  raise newException(ValueError, "No implementation available")

src/app/modules/main/wallet_section/collectibles/models/collectibles_model.nim

@@ -30,6 +30,7 @@ QtObject:
       allCollectiblesLoaded: bool
       isFetching: bool
       isError: bool
+      loadingItemsStartIdx: int
 
   proc appendLoadingItems(self: Model)
   proc removeLoadingItems(self: Model)
@@ -48,6 +49,7 @@ QtObject:
     result.allCollectiblesLoaded = false
     result.isFetching = false
     result.isError = false
+    result.loadingItemsStartIdx = -1
 
   proc `$`*(self: Model): string =
     for i in 0 ..< self.items.len:
@@ -181,27 +183,32 @@ QtObject:
       result = newQVariant(item.getIsPinned())
 
   proc appendLoadingItems(self: Model) =
+    if not self.loadingItemsStartIdx < 0:
+      return
+
     let parentModelIndex = newQModelIndex()
     defer: parentModelIndex.delete
 
     let loadingItem = initLoadingItem()
-    self.beginInsertRows(parentModelIndex, self.items.len, self.items.len + loadingItemsCount - 1)
+    self.loadingItemsStartIdx = self.items.len
+    self.beginInsertRows(parentModelIndex, self.loadingItemsStartIdx, self.loadingItemsStartIdx + loadingItemsCount - 1)
     for i in 1..loadingItemsCount:
       self.items.add(loadingItem)
     self.endInsertRows()
     self.countChanged()
 
   proc removeLoadingItems(self: Model) =
+    if self.loadingItemsStartIdx < 0:
+      return
+
     let parentModelIndex = newQModelIndex()
     defer: parentModelIndex.delete
 
-    for i in 0 ..< self.items.len:
-      if self.items[i].getIsLoading():
-        self.beginRemoveRows(parentModelIndex, i, i + loadingItemsCount - 1)
-        self.items.delete(i, i + loadingItemsCount - 1)
-        self.endRemoveRows()
-        self.countChanged()
-        return
+    self.beginRemoveRows(parentModelIndex, self.loadingItemsStartIdx, self.loadingItemsStartIdx + loadingItemsCount - 1)
+    self.items.delete(self.loadingItemsStartIdx, self.loadingItemsStartIdx + loadingItemsCount - 1)
+    self.loadingItemsStartIdx = -1
+    self.endRemoveRows()
+    self.countChanged()
 
   proc setItems*(self: Model, items: seq[Item]) =
     if self.isFetching:
@@ -224,8 +231,3 @@ QtObject:
     self.countChanged()
     if self.isFetching:
       self.appendLoadingItems()
-
-  # in case loading is still going on and no items are present, show loading items when there is no connection to opensea possible
-  proc connectionToOpenSea*(self: Model, connected: bool) =
-    if self.items.len == 0:
-      self.setIsFetching(not connected)

src/app/modules/main/wallet_section/collectibles/module.nim

@@ -108,27 +108,37 @@ method onFetchStarted*(self: Module, chainId: int, address: string) =
 
 method setCollectibles*(self: Module, chainId: int, address: string, data: CollectiblesData) =
   if self.chainId == chainId and self.address == address:
-    self.view.setIsFetching(data.isFetching)
     self.view.setIsError(data.isError)
 
+    if data.isError and not data.anyLoaded:
+      # If fetching failed before being able to get any collectibles info,
+      # show loading animation
+      self.view.setIsFetching(true)
+    else:
+      self.view.setIsFetching(data.isFetching)
+
     var newCollectibles = data.collectibles.map(oc => self.ownedCollectibleToItem(oc))
     self.view.setCollectibles(newCollectibles)
     self.view.setAllLoaded(data.allLoaded)
 
 method appendCollectibles*(self: Module, chainId: int, address: string, data: CollectiblesData) =
   if self.chainId == chainId and self.address == address:
-    self.view.setIsFetching(data.isFetching)
     self.view.setIsError(data.isError)
 
-    if not data.isError:
+    if data.isError and not data.anyLoaded:
+      # If fetching failed before being able to get any collectibles info,
+      # show loading animation
+      self.view.setIsFetching(true)
+    else:
+      self.view.setIsFetching(data.isFetching)
+
+    if data.lastLoadCount > 0:
       var ownedCollectiblesToAdd = newSeq[OwnedCollectible]()
       for i in data.collectibles.len - data.lastLoadCount ..< data.collectibles.len:
         ownedCollectiblesToAdd.add(data.collectibles[i])
 
       let newCollectibles = ownedCollectiblesToAdd.map(oc => self.ownedCollectibleToItem(oc))
 
       self.view.appendCollectibles(newCollectibles)
-      self.view.setAllLoaded(data.allLoaded)
 
-method connectionToOpenSea*(self: Module, connected: bool) =
-   self.view.connectionToOpenSea(connected)
+    self.view.setAllLoaded(data.allLoaded)

src/app/modules/main/wallet_section/collectibles/view.nim

@@ -49,5 +49,3 @@ QtObject:
   proc appendCollectibles*(self: View, collectibles: seq[Item]) =
     self.model.appendItems(collectibles)
 
-  proc connectionToOpenSea*(self: View, connected: bool) =
-    self.model.connectionToOpenSea(connected)

src/app/modules/main/wallet_section/current_account/controller.nim

@@ -4,6 +4,7 @@ import ../../../../../app_service/service/wallet_account/service as wallet_accou
 import ../../../../../app_service/service/network/service as network_service
 import ../../../../../app_service/service/token/service as token_service
 import ../../../../../app_service/service/currency/service as currency_service
+import ../../../../../app_service/service/collectible/service as collectible_service
 
 type
   Controller* = ref object of RootObj
@@ -12,20 +13,23 @@ type
     networkService: network_service.Service
     tokenService: token_service.Service
     currencyService: currency_service.Service
+    collectibleService: collectible_service.Service
 
 proc newController*(
   delegate: io_interface.AccessInterface,
   walletAccountService: wallet_account_service.Service,
   networkService: network_service.Service,
   tokenService: token_service.Service,
   currencyService: currency_service.Service,
+  collectibleService: collectible_service.Service,
 ): Controller =
   result = Controller()
   result.delegate = delegate
   result.walletAccountService = walletAccountService
   result.networkService = networkService
   result.tokenService = tokenService
   result.currencyService = currencyService
+  result.collectibleService = collectibleService
 
 proc delete*(self: Controller) =
   discard
@@ -58,4 +62,4 @@ proc getAllMigratedKeyPairs*(self: Controller): seq[KeyPairDto] =
   return self.walletAccountService.getAllMigratedKeyPairs()
 
 proc getHasCollectiblesCache*(self: Controller, address: string): bool  =
-  return self.walletAccountService.getHasCollectiblesCache(address)
+  return self.collectibleService.areCollectionsLoaded(address)

src/app/modules/main/wallet_section/current_account/module.nim

@@ -8,6 +8,7 @@ import ../../../../../app_service/service/wallet_account/service as wallet_accou
 import ../../../../../app_service/service/network/service as network_service
 import ../../../../../app_service/service/node/service as node_service
 import ../../../../../app_service/service/network_connection/service as network_connection
+import ../../../../../app_service/service/collectible/service as collectible_service
 import ../../../shared_models/currency_amount_utils
 import ../../../shared_models/currency_amount
 import ../../../shared_models/token_model as token_model
@@ -43,13 +44,14 @@ proc newModule*(
   networkService: network_service.Service,
   tokenService: token_service.Service,
   currencyService: currency_service.Service,
+  collectibleService: collectible_service.Service,
 ): Module =
   result = Module()
   result.delegate = delegate
   result.events = events
   result.currentAccountIndex = 0
   result.view = newView(result)
-  result.controller = newController(result, walletAccountService, networkService, tokenService, currencyService)
+  result.controller = newController(result, walletAccountService, networkService, tokenService, currencyService, collectibleService)
   result.moduleLoaded = false
 
 method delete*(self: Module) =

src/app/modules/main/wallet_section/module.nim

@@ -83,7 +83,7 @@ proc newModule*(
   result.accountsModule = accounts_module.newModule(result, events, walletAccountService, networkService, currencyService)
   result.allTokensModule = all_tokens_module.newModule(result, events, tokenService, walletAccountService)
   result.collectiblesModule = collectibles_module.newModule(result, events, collectibleService, walletAccountService, networkService, nodeService, networkConnectionService)
-  result.currentAccountModule = current_account_module.newModule(result, events, walletAccountService, networkService, tokenService, currencyService)
+  result.currentAccountModule = current_account_module.newModule(result, events, walletAccountService, networkService, tokenService, currencyService, collectibleService)
   result.transactionsModule = transactions_module.newModule(result, events, transactionService, walletAccountService, networkService, currencyService)
   result.savedAddressesModule = saved_addresses_module.newModule(result, events, savedAddressService)
   result.buySellCryptoModule = buy_sell_crypto_module.newModule(result, events, transactionService)