refactor(@desktop/profile-advance): profile advance module introduced

New advanced module added as submodule of the profile section module.
Advanced store introduced on the qml side and qml part updated accordingly.

src/app/boot/app_controller.nim

@@ -206,7 +206,8 @@ proc newAppController*(statusFoundation: StatusFoundation): AppController =
     result.providerService,
     result.stickersService,
     result.activityCenterService,
-    result.savedAddressService
+    result.savedAddressService,
+    result.nodeConfigurationService
   )
 
   # Do connections

src/app/modules/main/module.nim

@@ -35,6 +35,7 @@ import ../../../app_service/service/privacy/service as privacy_service
 import ../../../app_service/service/stickers/service as stickers_service
 import ../../../app_service/service/activity_center/service as activity_center_service
 import ../../../app_service/service/saved_address/service as saved_address_service
+import ../../../app_service/service/node_configuration/service_interface as node_configuration_service
 
 import eventemitter
 
@@ -81,8 +82,9 @@ proc newModule*[T](
   providerService: provider_service.ServiceInterface,
   stickersService: stickers_service.Service,
   activityCenterService: activity_center_service.Service,
-  savedAddressService: saved_address_service.ServiceInterface
-): Module[T] =
+  savedAddressService: saved_address_service.ServiceInterface,
+  nodeConfigurationService: node_configuration_service.ServiceInterface
+  ): Module[T] =
   result = Module[T]()
   result.delegate = delegate
   result.view = view.newView(result)
@@ -112,7 +114,8 @@ proc newModule*[T](
   result.browserSectionModule = browser_section_module.newModule(result, bookmarkService, settingsService, 
   dappPermissionsService, providerService)
   result.profileSectionModule = profile_section_module.newModule(result, events, accountsService, settingsService, 
-  profileService, contactsService, aboutService, languageService, mnemonicService, privacyService)
+  profileService, contactsService, aboutService, languageService, mnemonicService, privacyService,
+  nodeConfigurationService)
   result.stickersModule = stickers_module.newModule(result, events, stickersService)
   result.activityCenterModule = activity_center_module.newModule(result, events, activityCenterService, contactsService)
   result.communitiesModule = communities_module.newModule(result, events, communityService)

src/app/modules/main/profile_section/advanced/controller.nim

@@ -0,0 +1,138 @@
+import Tables, chronicles
+import controller_interface
+import io_interface
+
+import ../../../../core/fleets/fleet_configuration
+import ../../../../../app_service/service/settings/service_interface as settings_service
+import ../../../../../app_service/service/node_configuration/service_interface as node_configuration_service
+
+export controller_interface
+
+logScope:
+  topics = "profile-section-advanced-module-controller"
+
+type 
+  Controller* = ref object of controller_interface.AccessInterface
+    delegate: io_interface.AccessInterface
+    settingsService: settings_service.ServiceInterface
+    nodeConfigurationService: node_configuration_service.ServiceInterface
+
+proc newController*(delegate: io_interface.AccessInterface, settingsService: settings_service.ServiceInterface,
+  nodeConfigurationService: node_configuration_service.ServiceInterface): Controller =
+  result = Controller()
+  result.delegate = delegate
+  result.settingsService = settingsService
+  result.nodeConfigurationService = nodeConfigurationService
+  
+method delete*(self: Controller) =
+  discard
+
+method init*(self: Controller) = 
+  discard
+
+method getCurrentNetworkDetails*(self: Controller): settings_service.Network =
+  self.settingsService.getCurrentNetworkDetails()
+
+method changeCurrentNetworkTo*(self: Controller, network: string) =
+  if (not self.nodeConfigurationService.setNetwork(network)):
+    # in the future we may do a call from here to show a popup about this error
+    error "an error occurred, we couldn't change network"
+    return
+
+  var stickers: seq[StickerDto]
+  if (not self.settingsService.saveRecentStickers(stickers)):
+    # in the future we may do a call from here to show a popup about this error
+    error "an error occurred, we couldn't reset stickers for the network"
+    return
+
+  let stickerPacks = initTable[int, StickerPackDto]()
+  if (not self.settingsService.saveRecentStickers(stickerPacks)):
+    # in the future we may do a call from here to show a popup about this error
+    error "an error occurred, we couldn't reset stickers packs for the network"
+    return
+  
+  self.delegate.onCurrentNetworkSet()
+
+method getFleet*(self: Controller): string =
+  self.settingsService.getFleet()
+
+method changeFleetTo*(self: Controller, fleet: string) =
+  if (not self.nodeConfigurationService.setFleet(fleet)):
+    # in the future we may do a call from here to show a popup about this error
+    error "an error occurred, we couldn't set fleet"
+    return
+
+  var wakuVersion = WAKU_VERSION_1
+  if (fleet == $Fleet.WakuV2Prod or fleet == $Fleet.WakuV2Test): 
+    wakuVersion = WAKU_VERSION_2
+
+  if (not self.nodeConfigurationService.setWakuVersion(wakuVersion)):
+    # in the future we may do a call from here to show a popup about this error
+    error "an error occurred, we couldn't set waku version for the fleet"
+    return
+  
+  self.delegate.onFleetSet()
+
+method getBloomLevel*(self: Controller): string =
+  return self.nodeConfigurationService.getBloomLevel()
+
+method setBloomLevel*(self: Controller, bloomLevel: string) =
+  if (not self.nodeConfigurationService.setBloomLevel(bloomLevel)):
+    # in the future we may do a call from here to show a popup about this error
+    error "an error occurred, we couldn't set bloom level"
+    return
+  
+  self.delegate.onBloomLevelSet()
+
+method getWakuV2LightClientEnabled*(self: Controller): bool =
+  return self.nodeConfigurationService.getV2LightMode()
+
+method setWakuV2LightClientEnabled*(self: Controller, enabled: bool) =
+  if (self.nodeConfigurationService.setV2LightMode(enabled)):
+    # in the future we may do a call from here to show a popup about this error
+    error "an error occurred, we couldn't set WakuV2 light client"
+    return
+  
+  self.delegate.onWakuV2LightClientSet()
+
+method toggleTelemetry*(self: Controller) = 
+  var value = ""
+  if(not self.isTelemetryEnabled()):
+    value = DEFAULT_TELEMETRY_SERVER_URL
+
+  if(not self.settingsService.saveTelemetryServerUrl(value)):
+    # in the future we may do a call from here to show a popup about this error
+    error "an error occurred, we couldn't toggle telemetry message"
+    return
+  
+  self.delegate.onTelemetryToggled()
+  
+method isTelemetryEnabled*(self: Controller): bool = 
+  return self.settingsService.getTelemetryServerUrl().len > 0
+
+method toggleAutoMessage*(self: Controller) = 
+  let enabled = self.settingsService.autoMessageEnabled()
+  if(not self.settingsService.saveAutoMessageEnabled(not enabled)):
+    # in the future we may do a call from here to show a popup about this error
+    error "an error occurred, we couldn't toggle auto message"
+    return
+  
+  self.delegate.onAutoMessageToggled()
+
+method isAutoMessageEnabled*(self: Controller): bool = 
+  return self.settingsService.autoMessageEnabled()
+
+method toggleDebug*(self: Controller) = 
+  var logLevel = LogLevel.DEBUG
+  if(self.isDebugEnabled()):
+    logLevel = LogLevel.INFO
+
+  if(not self.nodeConfigurationService.setDebugLevel(logLevel)):
+    # in the future we may do a call from here to show a popup about this error
+    error "an error occurred, we couldn't toggle debug level"
+    return
+  
+  self.delegate.onDebugToggled()
+
+method isDebugEnabled*(self: Controller): bool = 
+  return self.nodeConfigurationService.getDebugLevel() == $LogLevel.DEBUG

src/app/modules/main/profile_section/advanced/controller_interface.nim

@@ -0,0 +1,53 @@
+import ../../../../../app_service/service/settings/dto/settings as settings_service_type
+
+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 getCurrentNetworkDetails*(self: AccessInterface): settings_service_type.Network {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method changeCurrentNetworkTo*(self: AccessInterface, network: string) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getFleet*(self: AccessInterface): string {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method changeFleetTo*(self: AccessInterface, fleet: string) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getBloomLevel*(self: AccessInterface): string {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method setBloomLevel*(self: AccessInterface, bloomLevel: string) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getWakuV2LightClientEnabled*(self: AccessInterface): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method setWakuV2LightClientEnabled*(self: AccessInterface, enabled: bool) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method toggleTelemetry*(self: AccessInterface) {.base.} = 
+  raise newException(ValueError, "No implementation available")
+
+method isTelemetryEnabled*(self: AccessInterface): bool {.base.} = 
+  raise newException(ValueError, "No implementation available")
+
+method toggleAutoMessage*(self: AccessInterface) {.base.} = 
+  raise newException(ValueError, "No implementation available")
+
+method isAutoMessageEnabled*(self: AccessInterface): bool {.base.} = 
+  raise newException(ValueError, "No implementation available")
+
+method toggleDebug*(self: AccessInterface) {.base.} = 
+  raise newException(ValueError, "No implementation available")
+
+method isDebugEnabled*(self: AccessInterface): bool {.base.} = 
+  raise newException(ValueError, "No implementation available") 

src/app/modules/main/profile_section/advanced/io_interface.nim

@@ -0,0 +1,11 @@
+# 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
+
+# Defines how submodules of this module communicate with this module

src/app/modules/main/profile_section/advanced/module.nim

@@ -0,0 +1,126 @@
+import NimQml, chronicles
+import io_interface
+import ../io_interface as delegate_interface
+import view, controller
+
+import ../../../../../constants
+import ../../../../global/global_singleton
+import ../../../../../app_service/service/settings/service_interface as settings_service
+import ../../../../../app_service/service/node_configuration/service_interface as node_configuration_service
+
+export io_interface
+
+logScope:
+  topics = "profile-section-advanced-module"
+
+type 
+  Module* = ref object of io_interface.AccessInterface
+    delegate: delegate_interface.AccessInterface
+    view: View
+    viewVariant: QVariant
+    controller: controller.AccessInterface
+    moduleLoaded: bool
+
+proc newModule*(delegate: delegate_interface.AccessInterface, settingsService: settings_service.ServiceInterface,
+  nodeConfigurationService: node_configuration_service.ServiceInterface): Module =
+  result = Module()
+  result.delegate = delegate
+  result.view = view.newView(result)
+  result.viewVariant = newQVariant(result.view)
+  result.controller = controller.newController(result, settingsService, nodeConfigurationService)
+  result.moduleLoaded = false
+  
+method delete*(self: Module) =
+  self.view.delete
+  self.viewVariant.delete
+  self.controller.delete
+
+method load*(self: Module) =
+  self.controller.init()
+  self.view.load()
+
+method isLoaded*(self: Module): bool =
+  return self.moduleLoaded
+
+method viewDidLoad*(self: Module) =
+  self.moduleLoaded = true
+  self.delegate.advancedModuleDidLoad()
+
+method getModuleAsVariant*(self: Module): QVariant =
+  return self.viewVariant
+
+method getCurrentNetworkName*(self: Module): string =
+  return self.controller.getCurrentNetworkDetails().name
+
+method getCurrentNetworkId*(self: Module): string =
+  return self.controller.getCurrentNetworkDetails().id
+  
+method setCurrentNetwork*(self: Module, network: string) =
+  self.controller.changeCurrentNetworkTo(network)
+
+method onCurrentNetworkSet*(self: Module) =
+  info "quit the app because of successful network change"
+  quit(QuitSuccess) # quits the app TODO: change this to logout instead when supported
+
+method getFleet*(self: Module): string =
+  return self.controller.getFleet()
+  
+method setFleet*(self: Module, fleet: string) =
+  self.controller.changeFleetTo(fleet)
+
+method onFleetSet*(self: Module) =
+  info "quit the app because of successful fleet change"
+  quit(QuitSuccess) # quits the app TODO: change this to logout instead when supported
+
+method getLogDir*(self: Module): string =
+  return url_fromLocalFile(constants.LOGDIR)
+
+method getBloomLevel*(self: Module): string =
+  return self.controller.getBloomLevel()
+
+method setBloomLevel*(self: Module, bloomLevel: string) =
+  self.controller.setBloomLevel(bloomLevel)
+
+method onBloomLevelSet*(self: Module) =
+  info "quit the app because of successful bloom level change"
+  quit(QuitSuccess) # quits the app TODO: change this to logout instead when supported
+
+method getWakuV2LightClientEnabled*(self: Module): bool =
+  return self.controller.getWakuV2LightClientEnabled()
+
+method setWakuV2LightClientEnabled*(self: Module, enabled: bool) =
+  self.controller.setWakuV2LightClientEnabled(enabled)
+
+method onWakuV2LightClientSet*(self: Module) =
+  info "quit the app because of successful WakuV2 light client change"
+  quit(QuitSuccess) # quits the app TODO: change this to logout instead when supported
+
+method isTelemetryEnabled*(self: Module): bool =
+  self.controller.isTelemetryEnabled()
+  
+method toggleTelemetry*(self: Module) = 
+  self.controller.toggleTelemetry()
+
+method onTelemetryToggled*(self: Module) =
+  self.view.emitTelemetryEnabledSignal()
+
+method isAutoMessageEnabled*(self: Module): bool =
+  self.controller.isAutoMessageEnabled()
+
+method toggleAutoMessage*(self: Module) = 
+  self.controller.toggleAutoMessage()
+
+method onAutoMessageToggled*(self: Module) =
+  self.view.emitAutoMessageEnabledSignal()
+
+method isDebugEnabled*(self: Module): bool =
+  self.controller.isDebugEnabled()
+
+method toggleDebug*(self: Module) = 
+  self.controller.toggleDebug()
+
+method onDebugToggled*(self: Module) =
+  info "quit the app because of successful debug level changed"
+  quit(QuitSuccess) # quits the app TODO: change this to logout instead when supported
+
+  

src/app/modules/main/profile_section/advanced/private_interfaces/module_access_interface.nim

@@ -0,0 +1,13 @@
+import NimQml
+
+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")
+
+method getModuleAsVariant*(self: AccessInterface): QVariant {.base.} =
+  raise newException(ValueError, "No implementation available")

src/app/modules/main/profile_section/advanced/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/profile_section/advanced/private_interfaces/module_controller_delegate_interface.nim

@@ -0,0 +1,20 @@
+method onCurrentNetworkSet*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available") 
+
+method onFleetSet*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+  
+method onBloomLevelSet*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available") 
+
+method onWakuV2LightClientSet*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method onTelemetryToggled*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available") 
+
+method onAutoMessageToggled*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available") 
+
+method onDebugToggled*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")

src/app/modules/main/profile_section/advanced/private_interfaces/module_view_delegate_interface.nim

@@ -0,0 +1,50 @@
+method viewDidLoad*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available") 
+
+method getCurrentNetworkName*(self: AccessInterface): string {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getCurrentNetworkId*(self: AccessInterface): string {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method setCurrentNetwork*(self: AccessInterface, network: string) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getFleet*(self: AccessInterface): string {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method setFleet*(self: AccessInterface, fleet: string) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getLogDir*(self: AccessInterface): string {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getBloomLevel*(self: AccessInterface): string {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method setBloomLevel*(self: AccessInterface, bloomLevel: string) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getWakuV2LightClientEnabled*(self: AccessInterface): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method setWakuV2LightClientEnabled*(self: AccessInterface, enabled: bool) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method isTelemetryEnabled*(self: AccessInterface): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+  
+method toggleTelemetry*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method isAutoMessageEnabled*(self: AccessInterface): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method toggleAutoMessage*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method isDebugEnabled*(self: AccessInterface): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method toggleDebug*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")

src/app/modules/main/profile_section/advanced/view.nim

@@ -0,0 +1,123 @@
+import NimQml
+import io_interface
+
+QtObject:
+  type
+    View* = ref object of QObject
+      delegate: io_interface.AccessInterface
+      
+  proc delete*(self: View) =
+    self.QObject.delete
+
+  proc newView*(delegate: io_interface.AccessInterface): View =
+    new(result, delete)
+    result.QObject.setup
+    result.delegate = delegate
+
+  proc load*(self: View) =
+    self.delegate.viewDidLoad()
+
+  proc currentNetworkChanged*(self: View) {.signal.}
+  proc getCurrentNetworkName*(self: View): string {.slot.} = 
+    return self.delegate.getCurrentNetworkName()
+  QtProperty[string] currentNetworkName:
+    read = getCurrentNetworkName
+    notify = currentNetworkChanged
+
+  proc setNetworkName*(self: View, network: string) {.slot.} = 
+    self.delegate.setCurrentNetwork(network)
+
+  # include this if we decide to not quit the app on network change
+  # proc emitNetworkSignal*(self: View) =
+  #   self.currentNetworkChanged()
+
+  proc getCurrentNetworkId*(self: View): string {.slot.} = 
+    return self.delegate.getCurrentNetworkId()
+  QtProperty[string] currentNetworkId:
+    read = getCurrentNetworkId
+    notify = currentNetworkChanged
+
+  proc fleetChanged*(self: View) {.signal.}
+  proc getFleet*(self: View): string {.slot.} = 
+    return self.delegate.getFleet()
+  QtProperty[string] fleet:
+    read = getFleet
+    notify = fleetChanged
+
+  proc setFleet*(self: View, fleet: string) {.slot.} = 
+    self.delegate.setFleet(fleet)
+
+  # include this if we decide to not quit the app on fleet change
+  # proc emitFleetSignal*(self: View) =
+  #   self.fleetChanged()
+
+  proc logDir*(self: View): string {.slot.} =
+    return self.delegate.getLogDir()
+
+  proc bloomLevelChanged*(self: View) {.signal.}
+  proc getBloomLevel*(self: View): string {.slot.} = 
+    return self.delegate.getBloomLevel()
+  QtProperty[string] bloomLevel:
+    read = getBloomLevel
+    notify = bloomLevelChanged
+
+  proc setBloomLevel*(self: View, bloomLevel: string) {.slot.} = 
+    self.delegate.setBloomLevel(bloomLevel)
+  
+  # include this if we decide to not quit the app on bloom level change
+  # proc emitBloomLevelSignal*(self: View) =
+  #   self.bloomLevelChanged()
+
+  proc wakuV2LightClientEnabledChanged*(self: View) {.signal.}
+  proc getWakuV2LightClientEnabled*(self: View): bool {.slot.} = 
+    return self.delegate.getWakuV2LightClientEnabled()
+  QtProperty[bool] wakuV2LightClientEnabled:
+    read = getWakuV2LightClientEnabled
+    notify = wakuV2LightClientEnabledChanged
+
+  proc setWakuV2LightClientEnabled*(self: View, enabled: bool) {.slot.} = 
+    self.delegate.setWakuV2LightClientEnabled(enabled)
+
+  # include this if we decide to not quit the app on waku v2 light client change
+  # proc emitWakuV2LightClientEnabledSignal*(self: View) =
+  #   self.wakuV2LightClientEnabledChanged() 
+
+  proc isTelemetryEnabledChanged*(self: View) {.signal.}
+  proc getIsTelemetryEnabled*(self: View): bool {.slot.} =
+    return self.delegate.isTelemetryEnabled()
+  QtProperty[bool] isTelemetryEnabled:
+    read = getIsTelemetryEnabled
+    notify = isTelemetryEnabledChanged
+
+  proc emitTelemetryEnabledSignal*(self: View) =
+    self.isTelemetryEnabledChanged()
+
+  proc toggleTelemetry*(self: View) {.slot.} = 
+    self.delegate.toggleTelemetry()
+
+  proc isAutoMessageEnabledChanged*(self: View) {.signal.}
+  proc getIsAutoMessageEnabled*(self: View): bool {.slot.} =
+    return self.delegate.isAutoMessageEnabled()
+  QtProperty[bool] isAutoMessageEnabled:
+    read = getIsAutoMessageEnabled
+    notify = isAutoMessageEnabledChanged
+
+  proc emitAutoMessageEnabledSignal*(self: View) =
+    self.isAutoMessageEnabledChanged()
+
+  proc toggleAutoMessage*(self: View) {.slot.} = 
+    self.delegate.toggleAutoMessage()
+
+  proc isDebugEnabledChanged*(self: View) {.signal.}
+  proc getIsDebugEnabled*(self: View): bool {.slot.} =
+    return self.delegate.isDebugEnabled()
+  QtProperty[bool] isDebugEnabled:
+    read = getIsDebugEnabled
+    notify = isDebugEnabledChanged
+
+  # include this if we decide to not quit the app on toggle debug
+  # proc emitDebugEnabledSignal*(self: View) =
+  #   self.isDebugEnabledChanged()
+
+  proc toggleDebug*(self: View) {.slot.} = 
+    self.delegate.toggleDebug()

src/app/modules/main/profile_section/controller.nim

@@ -1,72 +1,18 @@
-import Tables
-
 import controller_interface
 
-import ../../../../app_service/service/profile/service as profile_service
-import ../../../../app_service/service/accounts/service as accounts_service
-import ../../../../app_service/service/settings/service_interface as settings_service
-import ../../../../app_service/service/language/service as language_service
-import ../../../../app_service/service/mnemonic/service as mnemonic_service
-import ../../../../app_service/service/privacy/service as privacy_service
-
 export controller_interface
 
 type 
   Controller*[T: controller_interface.DelegateInterface] = 
     ref object of controller_interface.AccessInterface
     delegate: T
-    profileService: profile_service.ServiceInterface
-    settingsService: settings_service.ServiceInterface
-    accountsService: accounts_service.ServiceInterface
-    languageService: language_service.ServiceInterface
-    mnemonicService: mnemonic_service.ServiceInterface
-    privacyService: privacy_service.ServiceInterface
 
-proc newController*[T](delegate: T, accountsService: accounts_service.ServiceInterface, 
-  settingsService: settings_service.ServiceInterface, profileService: profile_service.ServiceInterface, 
-  languageService: language_service.ServiceInterface, mnemonicService: mnemonic_service.ServiceInterface, 
-  privacyService: privacy_service.ServiceInterface): Controller[T] =
+proc newController*[T](delegate: T): Controller[T] =
   result = Controller[T]()
   result.delegate = delegate
-  result.profileService = profileService
-  result.settingsService = settingsService
-  result.accountsService = accountsService
-  result.languageService = languageService
-  result.mnemonicService = mnemonicService
-  result.privacyService = privacyService
 
 method delete*[T](self: Controller[T]) =
   discard
 
 method init*[T](self: Controller[T]) = 
   discard
-
-method enableDeveloperFeatures*[T](self: Controller[T]) = 
-  self.settingsService.enableDeveloperFeatures()
-
-method toggleTelemetry*[T](self: Controller[T]) = 
-  var value = ""
-  if(not self.isTelemetryEnabled()):
-    value = DEFAULT_TELEMETRY_SERVER_URL
-
-  discard self.settingsService.saveTelemetryServerUrl(value)
-
-method isTelemetryEnabled*[T](self: Controller[T]): bool = 
-  return self.settingsService.getTelemetryServerUrl().len > 0
-
-method toggleAutoMessage*[T](self: Controller[T]) = 
-  let enabled = self.settingsService.autoMessageEnabled()
-  discard self.settingsService.saveAutoMessageEnabled(not enabled)
-
-method isAutoMessageEnabled*[T](self: Controller[T]): bool = 
-  return self.settingsService.autoMessageEnabled()
-
-method toggleDebug*[T](self: Controller[T]) = 
-  discard
-  # Need to sort out this
-  #self.settingsService.toggleDebug()
-
-method isDebugEnabled*[T](self: Controller[T]): bool = 
-  return true
-  # Need to sort out this
-  #return self.settingsService.isDebugEnabled()

src/app/modules/main/profile_section/controller_interface.nim

@@ -9,27 +9,6 @@ method delete*(self: AccessInterface) {.base.} =
 method init*(self: AccessInterface) {.base.} =
   raise newException(ValueError, "No implementation available")
 
-method enableDeveloperFeatures*(self: AccessInterface) {.base.} = 
-  raise newException(ValueError, "No implementation available")
-
-method toggleTelemetry*(self: AccessInterface) {.base.} = 
-  raise newException(ValueError, "No implementation available")
-
-method isTelemetryEnabled*(self: AccessInterface): bool {.base.} = 
-  raise newException(ValueError, "No implementation available")
-
-method toggleAutoMessage*(self: AccessInterface) {.base.} = 
-  raise newException(ValueError, "No implementation available")
-
-method isAutoMessageEnabled*(self: AccessInterface): bool {.base.} = 
-  raise newException(ValueError, "No implementation available")
-
-method toggleDebug*(self: AccessInterface) {.base.} = 
-  raise newException(ValueError, "No implementation available")
-
-method isDebugEnabled*(self: AccessInterface): bool {.base.} = 
-  raise newException(ValueError, "No implementation available")
-
 type
   ## Abstract class (concept) which must be implemented by object/s used in this 
   ## module.

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

@@ -1,3 +1,5 @@
+import NimQml
+
 type 
   AccessInterface* {.pure inheritable.} = ref object of RootObj
   ## Abstract class for any input/interaction with this module.
@@ -11,18 +13,6 @@ method load*(self: AccessInterface) {.base.} =
 method isLoaded*(self: AccessInterface): bool {.base.} =
   raise newException(ValueError, "No implementation available")
 
-method enableDeveloperFeatures*(self: AccessInterface) {.base.} =
-  raise newException(ValueError, "No implementation available")
-
-method toggleTelemetry*(self: AccessInterface) {.base.} =
-  raise newException(ValueError, "No implementation available")
-
-method toggleAutoMessage*(self: AccessInterface) {.base.} =
-  raise newException(ValueError, "No implementation available")
-
-method toggleDebug*(self: AccessInterface) {.base.} =
-  raise newException(ValueError, "No implementation available")
-
 # View Delegate Interface
 # Delegate for the view must be declared here due to use of QtObject and multi 
 # inheritance, which is not well supported in Nim.
@@ -48,6 +38,12 @@ method privacyModuleDidLoad*(self: AccessInterface) {.base.} =
 method aboutModuleDidLoad*(self: AccessInterface) {.base.} =
   raise newException(ValueError, "No implementation available")
 
+method advancedModuleDidLoad*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getAdvancedModule*(self: AccessInterface): QVariant {.base.} =
+  raise newException(ValueError, "No implementation available")
+
 type
   ## Abstract class (concept) which must be implemented by object/s used in this 
   ## module.

src/app/modules/main/profile_section/model.nim

@@ -1,17 +0,0 @@
-import NimQml
-import item
-
-QtObject:
-  type 
-    Model* = ref object of QAbstractListModel
-      sections: seq[Item]
-
-  proc setup(self: Model) = 
-    self.QAbstractListModel.setup
-
-  proc delete*(self: Model) =
-    self.QAbstractListModel.delete
-
-  proc newModel*(): Model =
-    new(result, delete)
-    result.setup

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

@@ -10,6 +10,7 @@ import ../../../../app_service/service/about/service as about_service
 import ../../../../app_service/service/language/service as language_service
 import ../../../../app_service/service/mnemonic/service as mnemonic_service
 import ../../../../app_service/service/privacy/service as privacy_service
+import ../../../../app_service/service/node_configuration/service_interface as node_configuration_service
 
 import ./profile/module as profile_module
 import ./contacts/module as contacts_module
@@ -17,6 +18,7 @@ import ./language/module as language_module
 import ./mnemonic/module as mnemonic_module
 import ./privacy/module as privacy_module
 import ./about/module as about_module
+import ./advanced/module as advanced_module
 
 import eventemitter
 
@@ -36,6 +38,7 @@ type
     mnemonicModule: mnemonic_module.AccessInterface
     privacyModule: privacy_module.AccessInterface
     aboutModule: about_module.AccessInterface
+    advancedModule: advanced_module.AccessInterface
 
 proc newModule*[T](delegate: T,
   events: EventEmitter,
@@ -46,14 +49,15 @@ proc newModule*[T](delegate: T,
   aboutService: about_service.ServiceInterface,
   languageService: language_service.ServiceInterface,
   mnemonicService: mnemonic_service.ServiceInterface,
-  privacyService: privacy_service.ServiceInterface
+  privacyService: privacy_service.ServiceInterface,
+  nodeConfigurationService: node_configuration_service.ServiceInterface
   ):
   Module[T] =
   result = Module[T]()
   result.delegate = delegate
   result.view = view.newView(result)
   result.viewVariant = newQVariant(result.view)
-  result.controller = controller.newController[Module[T]](result, accountsService, settingsService, profileService, languageService, mnemonicService, privacyService)
+  result.controller = controller.newController[Module[T]](result)
   result.moduleLoaded = false
 
   result.profileModule = profile_module.newModule(result, accountsService, settingsService, profileService)
@@ -62,6 +66,7 @@ proc newModule*[T](delegate: T,
   result.mnemonicModule = mnemonic_module.newModule(result, mnemonicService)
   result.privacyModule = privacy_module.newModule(result, privacyService, accountsService)
   result.aboutModule = about_module.newModule(result, aboutService)
+  result.advancedModule = advanced_module.newModule(result, settingsService, nodeConfigurationService)
 
   singletonInstance.engine.setRootContextProperty("profileSectionModule", result.viewVariant)
 
@@ -72,6 +77,7 @@ method delete*[T](self: Module[T]) =
   self.mnemonicModule.delete
   self.privacyModule.delete
   self.aboutModule.delete
+  self.advancedModule.delete
 
   self.view.delete
   self.viewVariant.delete
@@ -85,6 +91,7 @@ method load*[T](self: Module[T]) =
   self.mnemonicModule.load()
   self.privacyModule.load()
   self.aboutModule.load()
+  self.advancedModule.load()
 
 method isLoaded*[T](self: Module[T]): bool =
   return self.moduleLoaded
@@ -108,13 +115,13 @@ proc checkIfModuleDidLoad[T](self: Module[T]) =
   if(not self.aboutModule.isLoaded()):
     return
 
+  if(not self.advancedModule.isLoaded()):
+    return
+
   self.moduleLoaded = true
   self.delegate.profileSectionDidLoad()
 
 method viewDidLoad*[T](self: Module[T]) =
-  self.view.setIsTelemetryEnabled(self.controller.isTelemetryEnabled())
-  self.view.setIsDebugEnabled(self.controller.isDebugEnabled())
-  self.view.setIsAutoMessageEnabled(self.controller.isAutoMessageEnabled())
   self.checkIfModuleDidLoad()
 
 method profileModuleDidLoad*[T](self: Module[T]) =
@@ -135,14 +142,8 @@ method privacyModuleDidLoad*[T](self: Module[T]) =
 method aboutModuleDidLoad*[T](self: Module[T]) =
   self.checkIfModuleDidLoad()
 
-method enableDeveloperFeatures*[T](self: Module[T]) = 
-  self.controller.enableDeveloperFeatures()
+method advancedModuleDidLoad*[T](self: Module[T]) =
+  self.checkIfModuleDidLoad()
 
-method toggleTelemetry*[T](self: Module[T]) = 
-  self.controller.toggleTelemetry()
-
-method toggleAutoMessage*[T](self: Module[T]) = 
-  self.controller.toggleAutoMessage()
-
-method toggleDebug*[T](self: Module[T]) =
-  self.controller.toggleDebug()
+method getAdvancedModule*[T](self: Module[T]): QVariant =
+  self.advancedModule.getModuleAsVariant()

src/app/modules/main/profile_section/view.nim

@@ -6,12 +6,8 @@ QtObject:
   type
     View* = ref object of QObject
       delegate: io_interface.AccessInterface
-      # TODO: move to the correct module once all have been merged
-      isTelemetryEnabled: bool
-      isDebugEnabled: bool
-      isAutoMessageEnabled: bool
 
-  proc setup(self: View) =
+  proc setup(self: View) = 
     self.QObject.setup
 
   proc delete*(self: View) =
@@ -25,59 +21,8 @@ QtObject:
   proc load*(self: View) =
     self.delegate.viewDidLoad()
 
-  proc isTelemetryEnabledChanged*(self: View) {.signal.}
+  proc getAdvancedModule(self: View): QVariant {.slot.} =
+    return self.delegate.getAdvancedModule()
 
-  proc setIsTelemetryEnabled*(self: View, isTelemetryEnabled: bool) =
-    self.isTelemetryEnabled = isTelemetryEnabled
-    self.isTelemetryEnabledChanged()
-
-  proc getIsTelemetryEnabled*(self: View): QVariant {.slot.} =
-    return newQVariant(self.isTelemetryEnabled)
-
-  QtProperty[QVariant] isTelemetryEnabled:
-    read = getIsTelemetryEnabled
-    notify = isTelemetryEnabledChanged
-
-  proc toggleTelemetry*(self: View) {.slot.} =
-    self.delegate.toggleTelemetry()
-    self.setIsTelemetryEnabled(not self.isTelemetryEnabled)
-
-  proc isDebugEnabledChanged*(self: View) {.signal.}
-
-  proc setIsDebugEnabled*(self: View, isDebugEnabled: bool) =
-    self.isDebugEnabled = isDebugEnabled
-    self.isDebugEnabledChanged()
-
-  proc getIsDebugEnabled*(self: View): QVariant {.slot.} =
-    return newQVariant(self.isDebugEnabled)
-
-  QtProperty[QVariant] isDebugEnabled:
-    read = getIsDebugEnabled
-    notify = isDebugEnabledChanged
-
-  proc toggleDebug*(self: View) {.slot.} =
-    self.delegate.toggleDebug()
-    self.setIsDebugEnabled(not self.isDebugEnabled)
-
-  proc isAutoMessageEnabledChanged*(self: View) {.signal.}
-
-  proc setIsAutoMessageEnabled*(self: View, isAutoMessageEnabled: bool) =
-    self.isAutoMessageEnabled = isAutoMessageEnabled
-    self.isAutoMessageEnabledChanged()
-
-  proc getIsAutoMessageEnabled*(self: View): QVariant {.slot.} =
-    return newQVariant(self.isAutoMessageEnabled)
-
-  QtProperty[QVariant] isAutoMessageEnabled:
-    read = getIsAutoMessageEnabled
-    notify = isAutoMessageEnabledChanged
-
-  proc toggleAutoMessage*(self: View) {.slot.} =
-    self.delegate.toggleAutoMessage()
-    self.setIsAutoMessageEnabled(not self.isAutoMessageEnabled)
-
-  proc enableDeveloperFeatures*(self: View) {.slot.} =
-    self.delegate.enableDeveloperFeatures()
-    self.setIsTelemetryEnabled(true)
-    self.setIsDebugEnabled(true)
-    self.setIsAutoMessageEnabled(true)
+  QtProperty[QVariant] advancedModule:
+    read = getAdvancedModule

src/app_service/service/accounts/service.nim

@@ -217,7 +217,7 @@ proc getAccountSettings(self: Service, accountId: string,
 proc getDefaultNodeConfig*(self: Service, installationId: string): JsonNode =
   let networkConfig = getNetworkConfig(DEFAULT_NETWORK_NAME)
   let upstreamUrl = networkConfig["config"]["UpstreamConfig"]["URL"]
-  let fleet = Fleet.PROD
+  let fleet = Fleet.Prod
 
   var newDataDir = networkConfig["config"]["DataDir"].getStr
   newDataDir.removeSuffix("_rpc")

src/app_service/service/node_configuration/dto/node_config.nim

@@ -140,9 +140,9 @@ type
   
   PushNotificationServerConfig* = object
     Enabled*: bool
-    Identity*: seq[string] # not sure about the type, but we don't use it, so doesn't matter
+    #Identity*: seq[string] # not sure about the type, but we don't use it, so doesn't matter
     GorushURL*: string
-    Logger*: seq[string] # not sure about the type, but we don't use it, so doesn't matter
+    #Logger*: seq[string] # not sure about the type, but we don't use it, so doesn't matter
 
 type
   NodeConfigDto* = object
@@ -160,11 +160,11 @@ type
     HTTPEnabled*: bool
     HTTPHost*: string
     HTTPPort*: int
-    HTTPVirtualHosts*: string
-    HTTPCors*: string
+    # HTTPVirtualHosts*: string # not sure about the type, but we don't use it, so doesn't matter
+    # HTTPCors*: string # not sure about the type, but we don't use it, so doesn't matter
     IPCEnabled*: bool
     IPCFile*: string
-    TLSenabled*: bool
+    TLSEnabled*: bool
     MaxPeers*: int
     MaxPendingPeers*: int
     LogEnabled*: bool
@@ -385,16 +385,16 @@ proc toPushNotificationServerConfig*(jsonObj: JsonNode): PushNotificationServerC
   discard jsonObj.getProp("Enabled", result.Enabled)
   discard jsonObj.getProp("GorushURL", result.GorushURL)
 
-  var arr: JsonNode
-  if(jsonObj.getProp("Identity", arr)):
-    if(arr.kind == JArray):
-      for valueObj in arr:
-        result.Identity.add(valueObj.getStr)
+  # var arr: JsonNode
+  # if(jsonObj.getProp("Identity", arr)):
+  #   if(arr.kind == JArray):
+  #     for valueObj in arr:
+  #       result.Identity.add(valueObj.getStr)
 
-  if(jsonObj.getProp("Logger", arr)):
-    if(arr.kind == JArray):
-      for valueObj in arr:
-        result.Logger.add(valueObj.getStr)
+  # if(jsonObj.getProp("Logger", arr)):
+  #   if(arr.kind == JArray):
+  #     for valueObj in arr:
+  #       result.Logger.add(valueObj.getStr)
 
 proc toNodeConfigDto*(jsonObj: JsonNode): NodeConfigDto =
   discard jsonObj.getProp("NetworkId", result.NetworkId)
@@ -411,8 +411,8 @@ proc toNodeConfigDto*(jsonObj: JsonNode): NodeConfigDto =
   discard jsonObj.getProp("HTTPEnabled", result.HTTPEnabled)
   discard jsonObj.getProp("HTTPHost", result.HTTPHost)
   discard jsonObj.getProp("HTTPPort", result.HTTPPort)
-  discard jsonObj.getProp("HTTPVirtualHosts", result.HTTPVirtualHosts)
-  discard jsonObj.getProp("HTTPCors", result.HTTPCors)
+  # discard jsonObj.getProp("HTTPVirtualHosts", result.HTTPVirtualHosts)
+  # discard jsonObj.getProp("HTTPCors", result.HTTPCors)
   discard jsonObj.getProp("IPCEnabled", result.IPCEnabled)
   discard jsonObj.getProp("IPCFile", result.IPCFile)
   discard jsonObj.getProp("TLSEnabled", result.TLSEnabled)
@@ -446,7 +446,7 @@ proc toNodeConfigDto*(jsonObj: JsonNode): NodeConfigDto =
     result.ClusterConfig = toClusterConfig(clusterConfigObj)
 
   var lightEthConfigObj: JsonNode
-  if(jsonObj.getProp("ClusterConfig", lightEthConfigObj)):
+  if(jsonObj.getProp("LightEthConfig", lightEthConfigObj)):
     result.LightEthConfig = toLightEthConfig(lightEthConfigObj)
 
   var wakuConfigObj: JsonNode

src/app_service/service/node_configuration/service.nim

@@ -46,20 +46,41 @@ method init*(self: Service) =
     error "error: ", errDesription
     return
 
-proc saveConfiguration(self: Service, configuration: NodeConfigDto) =
+proc saveConfiguration(self: Service, configuration: NodeConfigDto): bool =
   if(not self.settingsService.saveNodeConfiguration(configuration.toJsonNode())):
     error "error saving node configuration "
-    return
+    return false
   self.configuration = configuration
+  return true
   
 method getWakuVersion*(self: Service): int =
   if self.configuration.WakuConfig.Enabled:
     return WAKU_VERSION_1
   elif self.configuration.WakuV2Config.Enabled:
     return WAKU_VERSION_2
+  
+  error "unsupported waku version"
   return 0
 
-method setWakuVersion*(self: Service, wakuVersion: int) =
+method getBloomLevel*(self: Service): string =
+  let wakuVersion = self.getWakuVersion()
+  if wakuVersion == WAKU_VERSION_2:
+    error "get - bloom level is supported only for a waku version 1"
+    return BLOOM_LEVEL_NORMAL
+
+  if wakuVersion == WAKU_VERSION_1:
+    let bloomFilterMode = self.configuration.WakuConfig.BloomFilterMode
+    let fullNode = self.configuration.WakuConfig.FullNode
+  
+    if (bloomFilterMode):
+      if(fullNode):
+        return BLOOM_LEVEL_FULL
+      else:
+        return BLOOM_LEVEL_NORMAL
+    else:
+      return BLOOM_LEVEL_LIGHT
+
+method setWakuVersion*(self: Service, wakuVersion: int): bool =
   var newConfiguration = self.configuration
   newConfiguration.RegisterTopics = @["whispermail"]
   newConfiguration.WakuConfig.Enabled = wakuVersion == WAKU_VERSION_1
@@ -73,12 +94,12 @@ method setWakuVersion*(self: Service, wakuVersion: int) =
     newConfiguration.Rendezvous = false
     newConfiguration.WakuV2Config.DiscoveryLimit = 20
     newConfiguration.WakuV2Config.Rendezvous = true
-  self.saveConfiguration(newConfiguration)
+  return self.saveConfiguration(newConfiguration)
 
-method setNetwork*(self: Service, network: string) =
+method setNetwork*(self: Service, network: string): bool =
   if(not self.settingsService.saveCurrentNetwork(network)):
     error "error saving network ", network, methodName="setNetwork"
-    return
+    return false
 
   let currentNetworkDetails = self.settingsService.getCurrentNetworkDetails()
   var dataDir = currentNetworkDetails.config.dataDir
@@ -89,29 +110,47 @@ method setNetwork*(self: Service, network: string) =
   newConfiguration.DataDir = dataDir
   newConfiguration.UpstreamConfig.Enabled = currentNetworkDetails.config.upstreamConfig.enabled
   newConfiguration.UpstreamConfig.URL = currentNetworkDetails.config.upstreamConfig.url
-  self.saveConfiguration(newConfiguration)
+  return self.saveConfiguration(newConfiguration)
   
-method setBloomFilterMode*(self: Service, bloomFilterMode: bool) =
+method setBloomFilterMode*(self: Service, bloomFilterMode: bool): bool =
   if(not self.settingsService.saveWakuBloomFilterMode(bloomFilterMode)):
     error "error saving waku bloom filter mode ", methodName="setBloomFilterMode"
-    return
+    return false
 
   var newConfiguration = self.configuration
   newConfiguration.WakuConfig.BloomFilterMode = bloomFilterMode
-  self.saveConfiguration(newConfiguration)
+  return self.saveConfiguration(newConfiguration)
+
+method setBloomLevel*(self: Service, bloomLevel: string): bool =
+  let wakuVersion = self.getWakuVersion()
+  if wakuVersion == WAKU_VERSION_2:
+    error "set - bloom level is supported only for a waku version 1"
+    return false
+
+  # default is BLOOM_LEVEL_NORMAL
+  var bloomFilterMode = false
+  var fullNode = true
+  if (bloomLevel == BLOOM_LEVEL_LIGHT):
+    bloomFilterMode = false
+    fullNode = false
+  elif (bloomLevel == BLOOM_LEVEL_FULL):
+    bloomFilterMode = true
+    fullNode = true
 
-method setBloomLevel*(self: Service, bloomFilterMode: bool, fullNode: bool) =
   if(not self.settingsService.saveWakuBloomFilterMode(bloomFilterMode)):
     error "error saving waku bloom filter mode ", methodName="setBloomLevel"
-    return
+    return false
 
-  var newConfiguration = self.configuration
-  newConfiguration.WakuConfig.BloomFilterMode = bloomFilterMode
-  newConfiguration.WakuConfig.FullNode = fullNode
-  newConfiguration.WakuConfig.LightClient = not fullNode
-  self.saveConfiguration(newConfiguration)
+  if wakuVersion == WAKU_VERSION_1:
+    var newConfiguration = self.configuration
+    newConfiguration.WakuConfig.BloomFilterMode = bloomFilterMode
+    newConfiguration.WakuConfig.FullNode = fullNode
+    newConfiguration.WakuConfig.LightClient = not fullNode
+    return self.saveConfiguration(newConfiguration)
 
-method setFleet*(self: Service, fleet: string) =
+  return false
+
+method setFleet*(self: Service, fleet: string): bool =
   if(not self.settingsService.saveFleet(fleet)):
     error "error saving fleet ", methodName="setFleet"
     return
@@ -130,9 +169,20 @@ method setFleet*(self: Service, fleet: string) =
   #TODO: in the meantime we're using the go-waku test fleet for rendezvous.
   #      once we have a prod fleet this code needs to be updated
   newConfiguration.ClusterConfig.WakuRendezvousNodes = self.fleetConfiguration.getNodes(Fleet.GoWakuTest, FleetNodes.LibP2P)
-  self.saveConfiguration(newConfiguration)
+  return self.saveConfiguration(newConfiguration)
 
-method setV2LightMode*(self: Service, enabled: bool) =
+method getV2LightMode*(self: Service): bool =
+  return self.configuration.WakuV2Config.LightClient
+
+method setV2LightMode*(self: Service, enabled: bool): bool =
   var newConfiguration = self.configuration
   newConfiguration.WakuV2Config.LightClient = enabled
-  self.saveConfiguration(newConfiguration)
+  return self.saveConfiguration(newConfiguration)
+
+method getDebugLevel*(self: Service): string =
+  return self.configuration.LogLevel
+
+method setDebugLevel*(self: Service, logLevel: LogLevel): bool =
+  var newConfiguration = self.configuration
+  newConfiguration.LogLevel = $logLevel
+  return self.saveConfiguration(newConfiguration)

src/app_service/service/node_configuration/service_interface.nim

@@ -1,9 +1,14 @@
+import chronicles
 import ./dto/node_config
 
 export node_config
+export chronicles
 
 const WAKU_VERSION_1* = 1
 const WAKU_VERSION_2* = 2
+const BLOOM_LEVEL_NORMAL* = "normal"
+const BLOOM_LEVEL_FULL* = "full"
+const BLOOM_LEVEL_LIGHT* = "light"
 
 type 
   ServiceInterface* {.pure inheritable.} = ref object of RootObj
@@ -18,20 +23,32 @@ method init*(self: ServiceInterface) {.base.} =
 method getWakuVersion*(self: ServiceInterface): int {.base.} =
   raise newException(ValueError, "No implementation available")
 
-method setWakuVersion*(self: ServiceInterface, wakuVersion: int) {.base.} =
+method getBloomLevel*(self: ServiceInterface): string {.base.} =
   raise newException(ValueError, "No implementation available")
 
-method setNetwork*(self: ServiceInterface, network: string) {.base.} =
+method setWakuVersion*(self: ServiceInterface, wakuVersion: int): bool {.base.} =
   raise newException(ValueError, "No implementation available")
 
-method setBloomFilterMode*(self: ServiceInterface, bloomFilterMode: bool) {.base.} =
+method setNetwork*(self: ServiceInterface, network: string): bool {.base.} =
   raise newException(ValueError, "No implementation available")
 
-method setBloomLevel*(self: ServiceInterface, bloomFilterMode: bool, fullNode: bool) {.base.} =
+method setBloomFilterMode*(self: ServiceInterface, bloomFilterMode: bool): bool {.base.} =
   raise newException(ValueError, "No implementation available")
 
-method setFleet*(self: ServiceInterface, fleet: string) {.base.} =
+method setBloomLevel*(self: ServiceInterface, bloomLevel: string): bool {.base.} =
   raise newException(ValueError, "No implementation available")
 
-method setV2LightMode*(self: ServiceInterface, enabled: bool) {.base.} =
+method setFleet*(self: ServiceInterface, fleet: string): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getV2LightMode*(self: ServiceInterface): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method setV2LightMode*(self: ServiceInterface, enabled: bool): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getDebugLevel*(self: ServiceInterface): string {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method setDebugLevel*(self: ServiceInterface, logLevel: LogLevel): bool {.base.} =
   raise newException(ValueError, "No implementation available")

src/app_service/service/settings/service.nim

@@ -275,6 +275,8 @@ method saveFleet*(self: Service, value: string): bool =
   return false
 
 method getFleet*(self: Service): string =
+  if(self.settings.fleet.len == 0):
+    self.settings.fleet = DEFAULT_FLEET
   return self.settings.fleet
 
 method getAvailableNetworks*(self: Service): seq[Network] =
@@ -329,7 +331,8 @@ method getRecentStickers*(self: Service): seq[string] =
   result = self.settings.recentStickerHashes
 
 method saveRecentStickers*(self: Service, recentStickers: seq[StickerDto]): bool =
-  if(self.saveSetting(KEY_RECENT_STICKERS, %(recentStickers.mapIt($it.hash)))):
+  let json = %(recentStickers.mapIt($it.hash))
+  if(self.saveSetting(KEY_RECENT_STICKERS, json)):
     self.settings.recentStickerHashes = recentStickers.map(s => s.hash)
     return true
   return false

src/app_service/service/settings/service_interface.nim

@@ -2,6 +2,7 @@ import json
 import tables
 import ./dto/settings as settings_dto
 import ../stickers/dto/stickers as stickers_dto
+import ../../../app/core/fleets/fleet_configuration
 
 export settings_dto
 export stickers_dto
@@ -10,6 +11,7 @@ export stickers_dto
 const DEFAULT_CURRENT_NETWORK* = "mainnet_rpc"
 const DEFAULT_CURRENCY* = "usd"
 const DEFAULT_TELEMETRY_SERVER_URL* = "https://telemetry.status.im"
+const DEFAULT_FLEET* = $Fleet.Prod
 
 type 
   ServiceInterface* {.pure inheritable.} = ref object of RootObj

ui/app/AppLayouts/Profile/ProfileLayout.qml

@@ -106,7 +106,7 @@ StatusAppTwoPanelLayout {
         }
 
         AdvancedView {
-            store: profileView.store
+            advancedStore: profileView.store.advancedStore
             profileContentWidth: _internal.profileContentWidth
         }
 

ui/app/AppLayouts/Profile/controls/FleetRadioSelector.qml

@@ -9,20 +9,22 @@ import shared.controls 1.0
 RadioButtonSelector {
     id: root
 
+    property var advancedStore
+
     property string fleetName: ""
     property string newFleet: ""
 
     title: fleetName
-    // Not Refactored Yet
-//    checked: profileModel.fleets.fleet === root.fleetName
+    checked: root.advancedStore.fleet === root.fleetName
 
     onCheckedChanged: {
-        // Not Refactored Yet
-//        if (checked) {
-//            if (profileModel.fleets.fleet === root.fleetName) return;
-//            root.newFleet = root.fleetName;
-//            Global.openPopup(confirmDialogComponent)
-//        }
+        if (checked) {
+            if (root.advancedStore.fleet === root.fleetName)
+                return
+
+            root.newFleet = root.fleetName;
+            Global.openPopup(confirmDialogComponent)
+        }
     }
 
     Component {
@@ -32,11 +34,10 @@ RadioButtonSelector {
             header.title: qsTrId("close-app-title")
             //% "Change fleet to %1"
             confirmationText: qsTrId("change-fleet-to--1").arg(root.newFleet)
-            // Not Refactored Yet
-//            onConfirmButtonClicked: profileModel.fleets.setFleet(root.newFleet)
+            onConfirmButtonClicked: {
+                root.advancedStore.setFleet(root.newFleet)
+            }
             onClosed: {
-                // Not Refactored Yet
-//                profileModel.fleets.triggerFleetChange()
                 destroy();
             }
         }

ui/app/AppLayouts/Profile/controls/NetworkRadioSelector.qml

@@ -10,18 +10,21 @@ import shared.controls 1.0
 RadioButtonSelector {
     id: root
 
+    property var advancedStore
     property string network: ""
     property string networkName: ""
     property string newNetwork: ""
 
     title: networkName == "" ? Utils.getNetworkName(network) : networkName
+    checked: root.advancedStore.currentNetworkName === root.title
 
     onCheckedChanged: {
         if (checked) {
-            // Not Refactored Yet
-//            if (profileModel.network.current === root.network) return;
-//            root.newNetwork = root.network;
-//            Global.openPopup(confirmDialogComponent)
+            if (root.advancedStore.currentNetworkName === root.network)
+                return
+
+            root.newNetwork = root.network;
+            Global.openPopup(confirmDialogComponent)
         }
     }
 
@@ -34,12 +37,9 @@ RadioButtonSelector {
             //% "The account will be logged out. When you unlock it again, the selected network will be used"
             confirmationText: qsTrId("logout-app-content")
             onConfirmButtonClicked: {
-                // Not Refactored Yet
-//                profileModel.network.current = root.newNetwork;
+                root.advancedStore.setNetworkName(root.newNetwork)
             }
             onClosed: {
-                // Not Refactored Yet
-//                profileModel.network.triggerNetworkChange()
                 destroy()
             }
         }

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

@@ -15,6 +15,8 @@ ModalPopup {
     //% "Fleet"
     title: qsTrId("fleet")
 
+    property var advancedStore
+
     property string newFleet: "";
     
     Column {
@@ -31,26 +33,31 @@ ModalPopup {
         ButtonGroup { id: fleetSettings }
 
         FleetRadioSelector {
+            advancedStore: popup.advancedStore
             fleetName: Constants.eth_prod
             buttonGroup: fleetSettings
         }
 
         FleetRadioSelector {
+            advancedStore: popup.advancedStore
             fleetName: Constants.eth_staging
             buttonGroup: fleetSettings
         }
 
         FleetRadioSelector {
+            advancedStore: popup.advancedStore
             fleetName: Constants.eth_test
             buttonGroup: fleetSettings
         }
 
         FleetRadioSelector {
+            advancedStore: popup.advancedStore
             fleetName: Constants.waku_prod
             buttonGroup: fleetSettings
         }
 
         FleetRadioSelector {
+            advancedStore: popup.advancedStore
             fleetName: Constants.waku_test
             buttonGroup: fleetSettings
         }

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

@@ -19,7 +19,7 @@ ModalPopup {
     //% "Network"
     title: qsTrId("network")
 
-    property string newNetwork: "";
+    property var advancedStore
  
     ScrollView {
         id: svNetworks
@@ -100,16 +100,19 @@ ModalPopup {
 
 
                 NetworkRadioSelector {
+                    advancedStore: popup.advancedStore
                     network: Constants.networkMainnet
                     buttonGroup: radioGroup
                 }
 
                 NetworkRadioSelector {
+                    advancedStore: popup.advancedStore
                     network: Constants.networkPOA
                     buttonGroup: radioGroup
                 }
 
                 NetworkRadioSelector {
+                    advancedStore: popup.advancedStore
                     network: Constants.networkXDai
                     buttonGroup: radioGroup
                 }
@@ -122,16 +125,19 @@ ModalPopup {
                 }
 
                 NetworkRadioSelector {
+                    advancedStore: popup.advancedStore
                     network: Constants.networkGoerli
                     buttonGroup: radioGroup
                 }
 
                 NetworkRadioSelector {
+                    advancedStore: popup.advancedStore
                     network: Constants.networkRinkeby
                     buttonGroup: radioGroup
                 }
 
                 NetworkRadioSelector {
+                    advancedStore: popup.advancedStore
                     network: Constants.networkRopsten
                     buttonGroup: radioGroup
                 }
@@ -147,6 +153,7 @@ ModalPopup {
 //                Repeater {
 //                    model: profileModel.network.customNetworkList
 //                    delegate: NetworkRadioSelector {
+//                        advancedStore: popup.advancedStore
 //                        networkName: name
 //                        network: customNetworkId
 //                        buttonGroup: radioGroup

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

@@ -0,0 +1,53 @@
+import QtQuick 2.13
+import utils 1.0
+
+QtObject {
+    id: root
+
+    property var advancedModule
+
+    // Advanced Module Properties
+    property string currentNetworkName: advancedModule.currentNetworkName
+    property string currentNetworkId: advancedModule.currentNetworkId
+    property string fleet: advancedModule.fleet
+    property string bloomLevel: advancedModule.bloomLevel
+    property bool wakuV2LightClientEnabled: advancedModule.wakuV2LightClientEnabled
+    property bool isTelemetryEnabled: advancedModule.isTelemetryEnabled
+    property bool isAutoMessageEnabled: advancedModule.isAutoMessageEnabled
+    property bool isDebugEnabled: advancedModule.isDebugEnabled
+
+    property bool isWakuV2: root.fleet === Constants.waku_prod ||
+                            root.fleet === Constants.waku_test
+
+    function logDir() {
+        return root.advancedModule.logDir()
+    }
+
+    function setNetworkName(networkName) {
+        root.advancedModule.setNetworkName(networkName)
+    }
+
+    function setFleet(fleetName) {
+        root.advancedModule.setFleet(fleetName)
+    }
+
+    function setBloomLevel(mode) {
+        root.advancedModule.setBloomLevel(mode)
+    }
+
+    function setWakuV2LightClientEnabled(mode) {
+        root.advancedModule.setWakuV2LightClientEnabled(mode)
+    }
+
+    function toggleTelemetry() {
+        root.advancedModule.toggleTelemetry()
+    }
+
+    function toggleAutoMessage() {
+        root.advancedModule.toggleAutoMessage()
+    }
+
+    function toggleDebug() {
+        root.advancedModule.toggleDebug()
+    }
+}

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

@@ -4,15 +4,17 @@ import utils 1.0
 QtObject {
     id: root
 
-    // Not Refactored Yet
-//    property var profileModelInst: profileModel
-    property var profileModuleInst: profileSectionModule
     property var profile: profileModule.model
     property var contactsModuleInst: contactsModule
     property var aboutModuleInst: aboutModule
     property var languageModuleInst: languageModule
     property var mnemonicModuleInst: mnemonicModule
 
+    property var profileModuleInst: profileSectionModule
+    property AdvancedStore advancedStore: AdvancedStore {
+        advancedModule: profileModuleInst.advancedModule
+    }
+
     // Not Refactored Yet
 //    property var chatsModelInst: chatsModel
     // Not Refactored Yet
@@ -43,11 +45,6 @@ QtObject {
     property string etherscanLink: "" //walletModelInst.utilsView.etherscanLink
     property string pubKey: profile.pubKey
     // Not Refactored Yet
-//    property string fleet: profileModelInst.fleets.fleet
-    // Not Refactored Yet
-//    property string bloomLevel: nodeModelInst.bloomLevel
-    // Not Refactored Yet
-//    property string currentNetwork: profileModelInst.network.current
 //    property string preferredUsername: profileModelInst.ens.preferredUsername
 //    property string firstEnsUsername: profileModelInst.ens.firstEnsUsername
     property string username: profile.username
@@ -59,8 +56,6 @@ QtObject {
     // Not Refactored Yet
 //    property bool automaticMailserverSelection: profileModelInst.mailservers.automaticSelection
     // Not Refactored Yet
-//    property bool isWakuV2LightClient: nodeModelInst.WakuV2LightClient
-    // Not Refactored Yet
 //    property bool devicesSetup: profileModelInst.devices.isSetup
     property bool mnemonicBackedUp: mnemonicModuleInst.isBackedUp
     property bool messagesFromContactsOnly: profile.messagesFromContactsOnly
@@ -338,11 +333,6 @@ QtObject {
 //        return utilsModelInst.getNetworkName()
     }
 
-    function logDir() {
-        // Not Refactored Yet
-//        return profileModelInst.logDir()
-    }
-
     function setBloomLevel(mode) {
         // Not Refactored Yet
 //        nodeModelInst.setBloomLevel(mode)

ui/app/AppLayouts/Profile/views/AdvancedView.qml

@@ -25,6 +25,8 @@ ScrollView {
     contentHeight: advancedContainer.height + 100
     clip: true
 
+    property var advancedStore
+
     Item {
         id: advancedContainer
         width: profileContentWidth
@@ -42,7 +44,7 @@ ScrollView {
             StatusSettingsLineButton {
                 //% "Network"
                 text: qsTrId("network")
-                currentValue: root.store.getNetworkName()
+                currentValue: root.advancedStore.currentNetworkName
                 onClicked: networksModal.open()
             }
 
@@ -50,7 +52,7 @@ ScrollView {
             StatusSettingsLineButton {
                 //% "Fleet"
                 text: qsTrId("fleet")
-                currentValue: root.store.fleet
+                currentValue: root.advancedStore.fleet
                 onClicked: fleetModal.open()
             }
 
@@ -80,7 +82,7 @@ ScrollView {
                     cursorShape: Qt.PointingHandCursor
                     hoverEnabled: true
                     onClicked: {
-                        Qt.openUrlExternally(root.store.logDir())
+                        Qt.openUrlExternally(root.advancedStore.logDir())
                     }
                 }
             }
@@ -236,7 +238,7 @@ ScrollView {
             }
 
             StatusSectionHeadline {
-                visible: !isWakuV2
+                visible: !root.advancedStore.isWakuV2
                 //% "Bloom filter level"
                 text: qsTrId("bloom-filter-level")
                 topPadding: Style.current.bigPadding
@@ -244,7 +246,7 @@ ScrollView {
             }
 
             Row {
-                visible: !isWakuV2
+                visible: !root.advancedStore.isWakuV2
                 spacing: 11
 
                 Component {
@@ -258,15 +260,14 @@ ScrollView {
                         //% "The account will be logged out. When you login again, the selected mode will be enabled"
                         confirmationText: qsTrId("the-account-will-be-logged-out--when-you-login-again--the-selected-mode-will-be-enabled")
                         onConfirmButtonClicked: {
-                            root.store.setBloomLevel(mode)
+                            root.advancedStore.setBloomLevel(mode)
                         }
                         onClosed: {
-                            // Not Refactored Yet
-//                            switch(root.store.nodeModelInst.bloomLevel){
-//                                case "light":  btnBloomLight.click(); break;
-//                                case "normal":  btnBloomNormal.click(); break;
-//                                case "full":  btnBloomFull.click(); break;
-//                            }
+                            switch(root.advancedStore.bloomLevel){
+                                case "light":  btnBloomLight.click(); break;
+                                case "normal":  btnBloomNormal.click(); break;
+                                case "full":  btnBloomFull.click(); break;
+                            }
                             destroy()
                         }
                     }
@@ -279,11 +280,11 @@ ScrollView {
                 BloomSelectorButton {
                     id: btnBloomLight
                     buttonGroup: bloomGroup
-                    checkedByDefault: root.store.bloomLevel == "light"
+                    checkedByDefault: root.advancedStore.bloomLevel == "light"
                     //% "Light Node"
                     btnText: qsTrId("light-node")
                     onToggled: {
-                        if (root.store.bloomLevel != "light") {
+                        if (root.advancedStore.bloomLevel != "light") {
                             Global.openPopup(bloomConfirmationDialogComponent, {mode: "light"})
                         } else {
                             btnBloomLight.click()
@@ -294,11 +295,11 @@ ScrollView {
                 BloomSelectorButton {
                     id: btnBloomNormal
                     buttonGroup: bloomGroup
-                    checkedByDefault: root.store.bloomLevel == "normal"
+                    checkedByDefault: root.advancedStore.bloomLevel == "normal"
                     //% "Normal"
                     btnText: qsTrId("normal")
                     onToggled: {
-                        if (root.store.bloomLevel != "normal") {
+                        if (root.advancedStore.bloomLevel != "normal") {
                             Global.openPopup(bloomConfirmationDialogComponent, {mode: "normal"})
                         } else {
                             btnBloomNormal.click()
@@ -309,11 +310,11 @@ ScrollView {
                 BloomSelectorButton {
                     id: btnBloomFull
                     buttonGroup: bloomGroup
-                    checkedByDefault: root.store.bloomLevel == "full"
+                    checkedByDefault: root.advancedStore.bloomLevel == "full"
                     //% "Full Node"
                     btnText: qsTrId("full-node")
                     onToggled: {
-                        if (root.store.bloomLevel != "full") {
+                        if (root.advancedStore.bloomLevel != "full") {
                             Global.openPopup(bloomConfirmationDialogComponent, {mode: "full"})
                         } else {
                             btnBloomFull.click()
@@ -323,7 +324,7 @@ ScrollView {
             }
 
             StatusSectionHeadline {
-                visible: isWakuV2
+                visible: root.advancedStore.isWakuV2
                 text: qsTr("WakuV2 mode")
                 topPadding: Style.current.bigPadding
                 bottomPadding: Style.current.padding
@@ -331,7 +332,7 @@ ScrollView {
 
             Row {
                 spacing: 11
-                visible: isWakuV2
+                visible: root.advancedStore.isWakuV2
                 Component {
                     id: wakuV2ModeConfirmationDialogComponent
                     ConfirmationDialog {
@@ -341,10 +342,10 @@ ScrollView {
                         //% "The account will be logged out. When you login again, the selected mode will be enabled"
                         confirmationText: qsTrId("the-account-will-be-logged-out--when-you-login-again--the-selected-mode-will-be-enabled")
                         onConfirmButtonClicked: {
-                            root.store.setWakuV2LightClient(mode)
+                            root.advancedStore.setWakuV2LightClientEnabled(mode)
                         }
                         onClosed: {
-                            if(root.store.isWakuV2LightClient){
+                            if(root.advancedStore.wakuV2LightClientEnabled){
                                 btnWakuV2Light.click()
                             } else {
                                 btnWakuV2Full.click();
@@ -361,11 +362,11 @@ ScrollView {
                 BloomSelectorButton {
                     id: btnWakuV2Light
                     buttonGroup: wakuV2Group
-                    checkedByDefault: root.store.isWakuV2LightClient
+                    checkedByDefault: root.advancedStore.wakuV2LightClientEnabled
                     //% "Light Node"
                     btnText: qsTrId("light-node")
                     onToggled: {
-                        if (!root.store.isWakuV2LightClient) {
+                        if (!root.advancedStore.wakuV2LightClientEnabled) {
                             Global.openPopup(wakuV2ModeConfirmationDialogComponent, {mode: true})
                         } else {
                             btnWakuV2Light.click()
@@ -376,11 +377,11 @@ ScrollView {
                 BloomSelectorButton {
                     id: btnWakuV2Full
                     buttonGroup: wakuV2Group
-                    checkedByDefault: !root.store.isWakuV2LightClient
+                    checkedByDefault: !root.advancedStore.wakuV2LightClientEnabled
                     //% "Full Node"
                     btnText: qsTrId("full-node")
                     onToggled: {
-                        if (root.store.isWakuV2LightClient) {
+                        if (root.advancedStore.wakuV2LightClientEnabled) {
                             Global.openPopup(wakuV2ModeConfirmationDialogComponent, {mode: false})
                         } else {
                             btnWakuV2Full.click()
@@ -402,7 +403,7 @@ ScrollView {
             // TODO: replace with StatusQ component
             StatusSettingsLineButton {
                 text: qsTr("Stickers/ENS on ropsten")
-                visible: root.store.currentNetwork === Constants.networkRopsten
+                visible: root.advancedStore.currentNetworkId === Constants.networkRopsten
                 isSwitch: true
                 switchChecked: localAccountSensitiveSettings.stickersEnsRopsten
                 onClicked: {
@@ -414,7 +415,7 @@ ScrollView {
             StatusSettingsLineButton {
                 text: qsTr("Enable Telemetry")
                 isSwitch: true
-                switchChecked: root.store.profileModuleInst.isTelemetryEnabled
+                switchChecked: root.advancedStore.isTelemetryEnabled
                 onClicked: {
                     Global.openPopup(enableTelemetryConfirmationDialogComponent, {light: false})
                 }
@@ -424,7 +425,7 @@ ScrollView {
             StatusSettingsLineButton {
                 text: qsTr("Debug")
                 isSwitch: true
-                switchChecked: root.store.profileModuleInst.isDebugEnabled
+                switchChecked: root.advancedStore.isDebugEnabled
                 onClicked: {
                     Global.openPopup(enableDebugComponent)
                 }
@@ -434,7 +435,7 @@ ScrollView {
             StatusSettingsLineButton {
                 text: qsTr("Enable Auto message")
                 isSwitch: true
-                switchChecked: root.store.profileModuleInst.isAutoMessageEnabled
+                switchChecked: root.advancedStore.isAutoMessageEnabled
                 onClicked: {
                     Global.openPopup(enableAutoMessageConfirmationDialogComponent, {light: false})
                 }
@@ -443,10 +444,12 @@ ScrollView {
 
         NetworksModal {
             id: networksModal
+            advancedStore: root.advancedStore
         }
 
         FleetsModal {
             id: fleetModal
+            advancedStore: root.advancedStore
         }
 
         Component {
@@ -458,7 +461,7 @@ ScrollView {
                 showCancelButton: true
                 confirmationText: qsTr("Are you sure you want to enable telemetry? This will reduce your privacy level while using Status. You need to restart the app for this change to take effect.")
                 onConfirmButtonClicked: {
-                    root.store.profileModuleInst.toggleTelemetry()
+                    root.advancedStore.toggleTelemetry()
                     close()
                 }
                 onCancelButtonClicked: {
@@ -476,7 +479,7 @@ ScrollView {
                 showCancelButton: true
                 confirmationText: qsTr("Are you sure you want to enable auto message? You need to restart the app for this change to take effect.")
                 onConfirmButtonClicked: {
-                    root.store.profileModuleInst.toggleAutoMessage()
+                    root.advancedStore.toggleAutoMessage()
                     close()
                 }
                 onCancelButtonClicked: {
@@ -492,11 +495,11 @@ ScrollView {
 
                 id: confirmDialog
                 showCancelButton: true
-                confirmationText: qsTr("Are you sure you want to %1 debug mode? The app will be restarted for this change to take effect.").arg(root.store.profileModuleInst.isDebugEnabled ? 
+                confirmationText: qsTr("Are you sure you want to %1 debug mode? The app will be restarted for this change to take effect.").arg(root.advancedStore.isDebugEnabled ?
                     qsTr("disable") : 
                     qsTr("enable"))
                 onConfirmButtonClicked: {
-                    root.store.profileModuleInst.toggleDebug()
+                    root.advancedStore.toggleDebug()
                     close()
                 }
                 onCancelButtonClicked: {