refactor: dapps and permissions

src/app/modules/main/browser_section/dapps/controller.nim

@@ -0,0 +1,44 @@
+import Tables
+import result
+import controller_interface
+import io_interface
+import options
+import ../../../../../app_service/service/dapp_permissions/service as dapp_permissions_service
+
+export controller_interface
+
+type 
+  Controller* = ref object of controller_interface.AccessInterface
+    delegate: io_interface.AccessInterface
+    dappPermissionsService: dapp_permissions_service.ServiceInterface
+
+proc newController*(delegate: io_interface.AccessInterface, 
+  dappPermissionsService: dapp_permissions_service.ServiceInterface): 
+  Controller =
+  result = Controller()
+  result.delegate = delegate
+  result.dappPermissionsService = dappPermissionsService
+  
+method delete*(self: Controller) =
+  discard
+
+method init*(self: Controller) = 
+  discard
+
+method getDapps*(self: Controller): seq[dapp_permissions_service.Dapp] =
+  return self.dappPermissionsService.getDapps()
+
+method getDapp*(self: Controller, dapp:string): Option[dapp_permissions_service.Dapp] =
+  return self.dappPermissionsService.getDapp(dapp)
+
+method hasPermission*(self: Controller, dapp: string, permission: dapp_permissions_service.Permission):bool =
+  return self.dappPermissionsService.hasPermission(dapp, permission)
+
+method clearPermissions*(self: Controller, dapp: string) =
+  discard self.dappPermissionsService.clearPermissions(dapp)
+
+method revokeAllPermisions*(self: Controller) =
+  discard self.dappPermissionsService.revokeAllPermisions()
+
+method revokePermission*(self: Controller, dapp: string, permission: string) =
+  discard self.dappPermissionsService.revoke(dapp, permission.toPermission())

src/app/modules/main/browser_section/dapps/controller_interface.nim

@@ -0,0 +1,30 @@
+import ../../../../../app_service/service/dapp_permissions/service_interface as dapp_permissions_service
+import options 
+
+type 
+  AccessInterface* {.pure inheritable.} = ref object of RootObj
+  ## Abstract class for any input/interaction with this module.
+
+method delete*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method init*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getDapps*(self: AccessInterface): seq[dapp_permissions_service.Dapp] {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getDapp*(self: AccessInterface, dapp: string): Option[dapp_permissions_service.Dapp] {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method hasPermission*(self: AccessInterface, dapp: string, permission: dapp_permissions_service.Permission):bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method clearPermissions*(self: AccessInterface, dapp: string) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method revokePermission*(self: AccessInterface, dapp: string, name: string) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method revokeAllPermisions*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")

src/app/modules/main/browser_section/dapps/dapps.nim

@@ -0,0 +1,71 @@
+import NimQml, Tables, strutils, strformat
+
+type
+  ModelRole {.pure.} = enum
+    Name = UserRole + 1
+
+QtObject:
+  type
+    DappsModel* = ref object of QAbstractListModel
+      items: seq[string]
+
+  proc delete(self: DappsModel) =
+    self.items = @[]
+    self.QAbstractListModel.delete
+
+  proc setup(self: DappsModel) =
+    self.QAbstractListModel.setup
+
+  proc newDappsModel*(): DappsModel =
+    new(result, delete)
+    result.setup
+
+  proc `$`*(self: DappsModel): string =
+    for i in 0 ..< self.items.len:
+      result &= fmt"""
+      [{i}]:({$self.items[i]})
+      """
+
+  proc modelChanged(self: DappsModel) {.signal.}
+
+  proc getCount(self: DappsModel): int {.slot.} =
+    self.items.len
+
+  QtProperty[int] count:
+    read = getCount
+    notify = countChanged
+
+  method rowCount(self: DappsModel, index: QModelIndex = nil): int =
+    return self.items.len
+
+  method roleNames(self: DappsModel): Table[int, string] =
+    {
+      ModelRole.Name.int:"name"
+    }.toTable
+
+  method data(self: DappsModel, index: QModelIndex, role: int): QVariant =
+    if (not index.isValid):
+      return
+
+    if (index.row < 0 or index.row >= self.items.len):
+      return
+
+    result = newQVariant(self.items[index.row])
+
+  proc addItem*(self: DappsModel, item: string) =
+    let parentModelIndex = newQModelIndex()
+    defer: parentModelIndex.delete
+
+    for i in self.items:
+      if i == item:
+        return
+    
+    self.beginInsertRows(parentModelIndex, self.items.len, self.items.len)
+    self.items.add(item)
+    self.endInsertRows()
+    self.modelChanged()
+
+  proc clear*(self: DappsModel) =
+    self.beginResetModel()
+    self.items = @[]
+    self.endResetModel()

src/app/modules/main/browser_section/dapps/io_interface.nim

@@ -0,0 +1,11 @@
+import ../../../../../app_service/service/dapp_permissions/service_interface as dapp_permissions_service
+
+# Defines how parent module accesses this module
+include ./private_interfaces/module_base_interface
+include ./private_interfaces/module_access_interface
+
+# Defines how this module view communicates with this module
+include ./private_interfaces/module_view_delegate_interface
+
+# Defines how this controller communicates with this module
+include ./private_interfaces/module_controller_delegate_interface

src/app/modules/main/browser_section/dapps/module.nim

@@ -0,0 +1,74 @@
+import NimQml
+import io_interface
+import ../io_interface as delegate_interface
+import view
+import sets
+import controller
+import ../../../../core/global_singleton
+import ../../../../../app_service/service/dapp_permissions/service as dapp_permissions_service
+import options
+export io_interface
+
+type 
+  Module* = ref object of io_interface.AccessInterface
+    delegate: delegate_interface.AccessInterface
+    view: View
+    viewVariant: QVariant
+    moduleLoaded: bool
+    controller: controller.AccessInterface
+
+proc newModule*(delegate: delegate_interface.AccessInterface, dappPermissionsService: dapp_permissions_service.ServiceInterface): Module =
+  result = Module()
+  result.delegate = delegate
+  result.view = view.newView(result)
+  result.viewVariant = newQVariant(result.view)
+  result.moduleLoaded = false
+  result.controller = controller.newController(result, dappPermissionsService)
+
+method delete*(self: Module) =
+  self.view.delete
+  self.viewVariant.delete
+  self.controller.delete
+
+method fetchDapps*(self: Module) =
+  self.view.clearDapps()
+  let dapps = self.controller.getDapps()
+  for d in dapps:
+    self.view.addDapp(d.name)
+
+method fetchPermissions(self: Module, dapp: string) =
+  self.view.clearPermissions()
+  let dapp = self.controller.getDapp(dapp)
+  if dapp.isSome:
+    for p in dapp.get().permissions.items:
+      self.view.addPermission($p)
+
+method load*(self: Module) =
+  singletonInstance.engine.setRootContextProperty("dappPermissionsModule", self.viewVariant)
+  self.view.load()
+  self.fetchDapps()
+
+method isLoaded*(self: Module): bool =
+  return self.moduleLoaded
+
+proc checkIfModuleDidLoad(self: Module) =
+  self.moduleLoaded = true
+  self.delegate.dappsDidLoad()
+
+method dappsDidLoad*(self: Module) =
+  self.checkIfModuleDidLoad()
+
+method viewDidLoad*(self: Module) =
+  self.checkIfModuleDidLoad()
+
+method hasPermission*(self: Module, hostname: string, permission: string): bool =
+  self.controller.hasPermission(hostname, permission.toPermission())
+
+method clearPermissions*(self: Module, dapp: string) =
+  self.controller.clearPermissions(dapp)
+
+method revokeAllPermissions*(self: Module) =
+  self.controller.revokeAllPermisions()
+
+method revokePermission*(self: Module, dapp: string, name: string) =
+  self.controller.revokePermission(dapp, name)

src/app/modules/main/browser_section/dapps/permissions.nim

@@ -0,0 +1,69 @@
+import NimQml, Tables, strutils, strformat
+
+type
+  ModelRole {.pure.} = enum
+    Name = UserRole + 1
+
+QtObject:
+  type
+    PermissionsModel* = ref object of QAbstractListModel
+      items: seq[string]
+
+  proc delete(self: PermissionsModel) =
+    self.items = @[]
+    self.QAbstractListModel.delete
+
+  proc setup(self: PermissionsModel) =
+    self.QAbstractListModel.setup
+
+  proc newPermissionsModel*(): PermissionsModel =
+    new(result, delete)
+    result.setup
+
+  proc `$`*(self: PermissionsModel): string =
+    for i in 0 ..< self.items.len:
+      result &= fmt"""
+      [{i}]:({$self.items[i]})
+      """
+
+  proc modelChanged(self: PermissionsModel) {.signal.}
+
+  proc getCount(self: PermissionsModel): int {.slot.} =
+    self.items.len
+
+  QtProperty[int] count:
+    read = getCount
+    notify = countChanged
+
+  method rowCount(self: PermissionsModel, index: QModelIndex = nil): int =
+    return self.items.len
+
+  method roleNames(self: PermissionsModel): Table[int, string] =
+    {
+      ModelRole.Name.int:"name"
+    }.toTable
+
+  method data(self: PermissionsModel, index: QModelIndex, role: int): QVariant =
+    if (not index.isValid):
+      return
+
+    if (index.row < 0 or index.row >= self.items.len):
+      return
+    result = newQVariant(self.items[index.row])
+
+  proc addItem*(self: PermissionsModel, item: string) =
+    let parentModelIndex = newQModelIndex()
+    defer: parentModelIndex.delete
+    for i in self.items:
+      if i == item:
+        return
+
+    self.beginInsertRows(parentModelIndex, self.items.len, self.items.len)
+    self.items.add(item)
+    self.endInsertRows()
+    self.modelChanged()
+
+  proc clear*(self: PermissionsModel) {.slot.} =
+    self.beginResetModel()
+    self.items = @[]
+    self.endResetModel()

src/app/modules/main/browser_section/dapps/private_interfaces/module_access_interface.nim

@@ -0,0 +1,8 @@
+method delete*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method load*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method isLoaded*(self: AccessInterface): bool {.base.} =
+  raise newException(ValueError, "No implementation available")

src/app/modules/main/browser_section/dapps/private_interfaces/module_base_interface.nim

@@ -0,0 +1,5 @@
+type 
+  AccessInterface* {.pure inheritable.} = ref object of RootObj
+
+# Since nim doesn't support using concepts in second level nested types we 
+# define delegate interfaces within access interface. 

src/app/modules/main/browser_section/dapps/private_interfaces/module_controller_delegate_interface.nim

@@ -0,0 +1,17 @@
+method hasPermission*(self: AccessInterface, hostname: string, permission: string): bool =
+  raise newException(ValueError, "No implementation available")
+
+method clearPermissions*(self: AccessInterface, dapp: string) =
+  raise newException(ValueError, "No implementation available")
+
+method revokePermission*(self: AccessInterface, dapp: string, name: string) =
+  raise newException(ValueError, "No implementation available")
+
+method revokeAllPermissions*(self: AccessInterface) =
+  raise newException(ValueError, "No implementation available")
+
+method fetchDapps*(self: AccessInterface) =
+  raise newException(ValueError, "No implementation available")
+
+method fetchPermissions*(self: AccessInterface, dapp: string) =
+  raise newException(ValueError, "No implementation available")

src/app/modules/main/browser_section/dapps/private_interfaces/module_view_delegate_interface.nim

@@ -0,0 +1,2 @@
+method viewDidLoad*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available") 

src/app/modules/main/browser_section/dapps/view.nim

@@ -0,0 +1,86 @@
+import NimQml
+import io_interface
+import dapps
+import permissions
+
+QtObject:
+  type
+    View* = ref object of QObject
+      delegate: io_interface.AccessInterface
+      dappsModel: DappsModel
+      permissionsModel: PermissionsModel
+      dappsModelVariant: QVariant
+      permissionsModelVariant: QVariant
+
+  proc setup(self: View) = 
+    self.QObject.setup
+
+  proc delete*(self: View) =
+    self.dappsModel.delete
+    self.permissionsModel.delete
+    self.dappsModelVariant.delete
+    self.permissionsModelVariant.delete
+    self.QObject.delete
+
+  proc newView*(delegate: io_interface.AccessInterface): View =
+    new(result, delete)
+    result.delegate = delegate
+    result.dappsModel = newDappsModel()
+    result.permissionsModel = newPermissionsModel()
+    result.dappsModelVariant = newQVariant(result.dappsModel)
+    result.permissionsModelVariant = newQVariant(result.permissionsModel)
+    result.setup()
+
+  proc load*(self: View) =
+    self.delegate.viewDidLoad()
+
+  proc addDapp*(self: View, item: string) =
+    self.dappsModel.addItem(item)
+
+  proc addPermission*(self: View, item: string) =
+    self.permissionsModel.addItem(item)
+
+  proc modelChanged*(self: View) {.signal.}
+
+  proc getPermissionsModel(self: View): QVariant {.slot.} =
+    return self.permissionsModelVariant
+
+  proc getDappsModel(self: View): QVariant {.slot.} =
+    return self.dappsModelVariant
+
+  QtProperty[QVariant] permissions:
+    read = getPermissionsModel
+    notify = modelChanged
+
+  QtProperty[QVariant] dapps:
+    read = getDappsModel
+    notify = modelChanged
+
+  proc hasPermission(self: View, hostname: string, permission: string): bool {.slot.} =
+    return self.delegate.hasPermission(hostname, permission)
+  
+  proc clearPermissions(self: View, dapp: string): string {.slot.} =
+    self.delegate.clearPermissions(dapp)
+
+  proc revokePermission(self: View, dapp: string, name: string) {.slot.} =
+    self.delegate.revokePermission(dapp, name)
+
+  proc revokeAllPermissions(self: View) {.slot.} =
+    self.delegate.revokeAllPermissions()
+
+  proc ensResourceURL*(self: View, ens: string, url: string): string {.slot.} =
+    discard # TODO:
+    #let (url, base, http_scheme, path_prefix, hasContentHash) = self.status.provider.ensResourceURL(ens, url)
+    #result = url_replaceHostAndAddPath(url, (if hasContentHash: base else: url_host(base)), http_scheme, path_prefix)
+
+  proc clearDapps*(self: View) =
+    self.dappsModel.clear()
+
+  proc clearPermissions*(self: View) =
+    self.permissionsModel.clear()
+
+  proc fetchDapps(self: View) {.slot.} =
+    self.delegate.fetchDapps()
+
+  proc fetchPermissions(self: View, dapp: string) {.slot.} =
+    self.delegate.fetchPermissions(dapp)

src/app/modules/main/browser_section/io_interface.nim

@@ -12,3 +12,4 @@ include ./private_interfaces/module_controller_delegate_interface
 # will be added if needed
 include ./private_interfaces/module_provider_delegate_interface
 include ./private_interfaces/module_bookmark_delegate_interface
+include ./private_interfaces/module_dapps_delegate_interface

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

@@ -5,8 +5,10 @@ import view
 import ../../../core/global_singleton
 import provider/module as provider_module
 import bookmark/module as bookmark_module
+import dapps/module as dapps_module
 import ../../../../app_service/service/bookmarks/service as bookmark_service
 import ../../../../app_service/service/settings/service as settings_service
+import ../../../../app_service/service/dapp_permissions/service as dapp_permissions_service
 export io_interface
 
 type 
@@ -17,8 +19,9 @@ type
     moduleLoaded: bool
     providerModule: provider_module.AccessInterface
     bookmarkModule: bookmark_module.AccessInterface
+    dappsModule: dapps_module.AccessInterface
 
-proc newModule*(delegate: delegate_interface.AccessInterface, bookmarkService: bookmark_service.ServiceInterface, settingsService: settings_service.ServiceInterface): Module =
+proc newModule*(delegate: delegate_interface.AccessInterface, bookmarkService: bookmark_service.ServiceInterface, settingsService: settings_service.ServiceInterface, dappPermissionsService: dapp_permissions_service.ServiceInterface): Module =
   result = Module()
   result.delegate = delegate
   result.view = view.newView(result)
@@ -26,17 +29,20 @@ proc newModule*(delegate: delegate_interface.AccessInterface, bookmarkService: b
   result.moduleLoaded = false
   result.providerModule = provider_module.newModule(result, settingsService)
   result.bookmarkModule = bookmark_module.newModule(result, bookmarkService)
+  result.dappsModule = dapps_module.newModule(result, dappPermissionsService)
 
 method delete*(self: Module) =
   self.view.delete
   self.viewVariant.delete
   self.providerModule.delete
   self.bookmarkModule.delete
+  self.dappsModule.delete
 
 method load*(self: Module) =
   singletonInstance.engine.setRootContextProperty("browserSection", self.viewVariant)
   self.providerModule.load()
   self.bookmarkModule.load()
+  self.dappsModule.load()
   self.view.load()
 
 method isLoaded*(self: Module): bool =
@@ -49,6 +55,9 @@ proc checkIfModuleDidLoad(self: Module) =
   if(not self.bookmarkModule.isLoaded()):
     return
 
+  if(not self.dappsModule.isLoaded()):
+    return
+
   self.moduleLoaded = true
   self.delegate.browserSectionDidLoad()
 
@@ -58,6 +67,9 @@ method providerDidLoad*(self: Module) =
 method bookmarkDidLoad*(self: Module) =
   self.checkIfModuleDidLoad()
 
+method dappsDidLoad*(self: Module) =
+  self.checkIfModuleDidLoad()
+
 method viewDidLoad*(self: Module) =
   self.checkIfModuleDidLoad()
 

src/app/modules/main/browser_section/private_interfaces/module_dapps_delegate_interface.nim

@@ -0,0 +1,2 @@
+method dappsDidLoad*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")

src/app/modules/main/module.nim

@@ -99,7 +99,7 @@ proc newModule*[T](
     settingService
   )
 
-  result.browserSectionModule = browser_section_module.newModule(result, bookmarkService, settingsService)
+  result.browserSectionModule = browser_section_module.newModule(result, bookmarkService, settingsService, dappPermissionsService)
   result.profileSectionModule = profile_section_module.newModule(result, events, accountsService, settingsService, profileService, contactsService, aboutService)
 
 method delete*[T](self: Module[T]) =

src/app/profile/view.nim

@@ -1,5 +1,5 @@
 import NimQml, sequtils, strutils, sugar, os, json, chronicles
-import views/[mailservers_list, ens_manager, contacts, devices, mailservers, mnemonic, network, fleets, profile_info, device_list, dapp_list, profile_picture, muted_chats]
+import views/[mailservers_list, ens_manager, contacts, devices, mailservers, mnemonic, network, fleets, profile_info, device_list, profile_picture, muted_chats]
 import chronicles
 import qrcode/qrcode
 
@@ -32,7 +32,6 @@ QtObject:
     devices*: DevicesView
     mailservers*: MailserversView
     mnemonic*: MnemonicView
-    dappList*: DappList
     fleets*: Fleets
     network*: NetworkView
     status*: Status
@@ -50,7 +49,6 @@ QtObject:
     if not self.profilePicture.isNil: self.profilePicture.delete
     if not self.mutedChats.isNil: self.mutedChats.delete
     if not self.profile.isNil: self.profile.delete
-    if not self.dappList.isNil: self.dappList.delete
     if not self.fleets.isNil: self.fleets.delete
     if not self.network.isNil: self.network.delete
     if not self.mnemonic.isNil: self.mnemonic.delete
@@ -69,7 +67,6 @@ QtObject:
     result.network = newNetworkView(status)
     result.mnemonic = newMnemonicView(status)
     result.mailservers = newMailserversView(status, appService)
-    result.dappList = newDappList(status)
     result.ens = newEnsManager(status, appService)
     result.fleets = newFleets(status)
     result.changeLanguage = changeLanguage
@@ -109,12 +106,6 @@ QtObject:
     self.profile.setAppearance(theme)
     self.status.saveSetting(Setting.Appearance, $theme)
 
-  proc getDappList(self: ProfileView): QVariant {.slot.} =
-    return newQVariant(self.dappList)
-
-  QtProperty[QVariant] dappList:
-    read = getDappList
-
   proc getFleets(self: ProfileView): QVariant {.slot.} =
     return newQVariant(self.fleets)
 

src/app/profile/views/dapp_list.nim

@@ -1,64 +0,0 @@
-import NimQml
-import Tables
-import status/status
-import status/types/permission
-import permission_list
-
-type
-  DappsRoles {.pure.} = enum
-    Name = UserRole + 1,
-
-QtObject:
-  type DappList* = ref object of QAbstractListModel
-    status: Status
-    dapps: seq[Dapp]
-    permissionList: PermissionList
-
-  proc setup(self: DappList) = self.QAbstractListModel.setup
-
-  proc delete(self: DappList) =
-    self.dapps = @[]
-    self.permissionList.delete
-    self.QAbstractListModel.delete
-
-  proc newDappList*(status: Status): DappList =
-    new(result, delete)
-    result.status = status
-    result.permissionList = newPermissionList(status)
-    result.dapps =  @[]
-    result.setup
-
-  proc init*(self: DappList) {.slot.} =
-    self.beginResetModel()
-    self.dapps = self.status.permissions.getDapps()
-    self.endResetModel()
-
-  method rowCount(self: DappList, index: QModelIndex = nil): int =
-    return self.dapps.len
-
-  method data(self: DappList, index: QModelIndex, role: int): QVariant =
-    if not index.isValid:
-      return
-    if index.row < 0 or index.row >= self.dapps.len:
-      return
-    result = newQVariant(self.dapps[index.row].name)
-
-  method roleNames(self: DappList): Table[int, string] =
-    {
-      DappsRoles.Name.int:"name",
-    }.toTable
-
-  proc clearData(self: DappList) {.slot.} =
-    self.beginResetModel()
-    self.dapps = @[]
-    self.endResetModel()
-
-  proc revokeAllPermissions(self: DappList) {.slot.} =
-    self.status.permissions.clearPermissions()
-    self.clearData()
-
-  proc getPermissionList(self: DappList): QVariant {.slot.} =
-    return newQVariant(self.permissionList)
-
-  QtProperty[QVariant] permissionList:
-    read = getPermissionList

src/app_service/service/dapp_permissions/dto/dapp.nim

@@ -10,6 +10,6 @@ type Dapp* = object
 proc toDapp*(jsonObj: JsonNode): Dapp =
   result = Dapp()
   result.permissions = initHashSet[Permission]()
-  discard jsonObj.getProp("name", result.name)
+  discard jsonObj.getProp("dapp", result.name)
   for permission in jsonObj["permissions"].getElems():
     result.permissions.incl(permission.getStr().toPermission())

src/app_service/service/dapp_permissions/service.nim

@@ -42,15 +42,13 @@ method getDapp*(self: Service, dapp: string): Option[Dapp] =
     return some(self.dapps[dapp])
   return none(Dapp)
 
-method clearPermissions*(self: Service, dapp: string): R =
+method clearPermissions*(self: Service, dapp: string): bool =
   try:
     if not self.dapps.hasKey(dapp):
-      result.err "not found"
       return
-
     discard status_go.deleteDappPermissions(dapp)
-    self.dapps[dapp].permissions.clear()
-    result.ok self.dapps[dapp]
+    self.dapps.del(dapp)
+    return true
   except Exception as e:
     let errDescription = e.msg
     error "error: ", errDescription
@@ -64,15 +62,15 @@ method revoke*(self: Service, permission: Permission): bool =
           discard status_go.addDappPermissions(dapp.name, dapp.permissions.toSeq().mapIt($it))
         else:
           discard status_go.deleteDappPermissions(dapp.name)
+          self.dapps.del(dapp.name)
     return true
   except Exception as e:
     let errDescription = e.msg
     error "error: ", errDescription
 
-method revoke*(self: Service, dapp: string, permission: Permission): R =
+method revoke*(self: Service, dapp: string, permission: Permission): bool =
   try:
     if not self.dapps.hasKey(dapp):
-      result.err "not found"
       return
 
     if self.dapps[dapp].permissions.contains(permission):
@@ -81,11 +79,11 @@ method revoke*(self: Service, dapp: string, permission: Permission): R =
         discard status_go.addDappPermissions(dapp, self.dapps[dapp].permissions.toSeq().mapIt($it))
       else:
         discard status_go.deleteDappPermissions(dapp)
-    result.ok self.dapps[dapp]
+        self.dapps.del(dapp)
+    return true
   except Exception as e:
     let errDescription = e.msg
     error "error: ", errDescription
-    result.err errDescription
 
 method addPermission*(self: Service, dapp: string, permission: Permission): R =
   try:
@@ -100,3 +98,18 @@ method addPermission*(self: Service, dapp: string, permission: Permission): R =
     let errDescription = e.msg
     error "error: ", errDescription
     result.err errDescription
+
+method revokeAllPermisions*(self: Service): bool =
+  try:
+    for d in self.dapps.values:
+      discard status_go.deleteDappPermissions(d.name)
+    self.dapps.clear()
+    return true
+  except Exception as e:
+    let errDescription = e.msg
+    error "error: ", errDescription
+
+method hasPermission*(self: Service, dapp: string, permission: Permission): bool =
+  if not self.dapps.hasKey(dapp):
+    return false
+  return self.dapps[dapp].permissions.contains(permission)

src/app_service/service/dapp_permissions/service_interface.nim

@@ -23,13 +23,19 @@ method getDapps*(self: ServiceInterface): seq[Dapp] {.base.} =
 method getDapp*(self: ServiceInterface, dapp: string): Option[Dapp] {.base.} =
   raise newException(ValueError, "No implementation available")
 
-method clearPermissions*(self: ServiceInterface, dapp: string): R {.base.} =
+method hasPermission*(self: ServiceInterface, dapp: string, permission: Permission): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method clearPermissions*(self: ServiceInterface, dapp: string): bool {.base.} =
   raise newException(ValueError, "No implementation available")
 
 method revoke*(self: ServiceInterface, permission: Permission): bool {.base.} =
   raise newException(ValueError, "No implementation available")
 
-method revoke*(self: ServiceInterface, dapp: string, permission: Permission): R {.base.} =
+method revoke*(self: ServiceInterface, dapp: string, permission: Permission): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method revokeAllPermisions*(self: ServiceInterface): bool {.base.} =
   raise newException(ValueError, "No implementation available")
 
 method addPermission*(self: ServiceInterface, dapp: string, permission: Permission): R {.base.}  =

ui/app/AppLayouts/Profile/popups/DappList.qml

@@ -18,7 +18,6 @@ ModalPopup {
     property var store
 
     Component.onCompleted: store.initDappList()
-    Component.onDestruction: store.clearDappList()
 
     property Component permissionListPopup: PermissionList {
         onClosed: destroy()
@@ -45,7 +44,7 @@ ModalPopup {
                 model: root.store.dappList
                 delegate: Dapp {
                   name: model.name
-                  onDappClicked: permissionListPopup.createObject(privacyContainer, {dapp: dapp}).open()
+                  onDappClicked: permissionListPopup.createObject(appMain, {dapp: dapp}).open()
                 }
             }
         }

ui/app/AppLayouts/Profile/popups/PermissionList.qml

@@ -26,7 +26,6 @@ ModalPopup {
     property var store
 
     Component.onCompleted: store.initPermissionList(dapp)
-    Component.onDestruction: store.clearPermissionList()
 
     signal accessRevoked(string dapp)
 
@@ -50,7 +49,7 @@ ModalPopup {
                 delegate: Permission {
                   name: model.name
                   onRemoveBtnClicked: {
-                      root.store.revokePermission(model.name);
+                      root.store.revokePermission(dapp, model.name);
                       if(permissionListView.count === 1){
                             accessRevoked(dapp);
                             close();
@@ -68,7 +67,7 @@ ModalPopup {
         //% "Revoke all access"
         text: qsTrId("revoke-all-access")
         onClicked: {
-            root.store.revokeAllPermissionAccess()
+            root.store.clearPermissions(dapp)
             accessRevoked(dapp);
             close();
         }

ui/app/AppLayouts/Profile/stores/RootStore.qml

@@ -16,8 +16,8 @@ QtObject {
     property var nodeModelInst: nodeModel
 
     property var ens: profileModelInst.ens
-    property var dappList: profileModelInst.dappList
-    property var permissionList: profileModelInst.dappList.permissionList
+    property var dappList: dappPermissionsModule.dapps
+    property var permissionList: dappPermissionsModule.permissions
     property var mailservers: profileModelInst.mailservers
     property var mailserversList: profileModelInst.mailservers.list
     property var contacts: contactsModuleInst.model.list
@@ -153,27 +153,19 @@ QtObject {
     }
 
     function initPermissionList(name) {
-        profileModelInst.dappList.permissionList.init(name)
+        dappPermissionsModule.fetchPermissions(name)
     }
 
-    function clearPermissionList() {
-        profileModelInst.dappList.permissionList.clearData()
+    function revokePermission(dapp, name) {
+        dappPermissionsModule.revokePermission(dapp, name)
     }
 
-    function revokePermission(name) {
-        profileModelInst.dappList.permissionList.revokePermission(name)
-    }
-
-    function revokeAllPermissionAccess() {
-        profileModelInst.dappList.permissionList.revokeAccess()
+    function clearPermissions(dapp) {
+        dappPermissionsModule.clearPermissions(dapp)
     }
 
     function initDappList() {
-        profileModelInst.dappList.init()
-    }
-
-    function clearDappList() {
-        profileModelInst.dappList.clearData()
+        dappPermissionsModule.fetchDapps()
     }
 
     function getQrCodeSource(publicKey) {