Cell capacity feature

PresentationLayer/Extensions/DomainExtensions/PublicHex+.swift

@@ -0,0 +1,18 @@
+//
+//  PublicHexes+.swift
+//  wxm-ios
+//
+//  Created by Pantelis Giazitsis on 26/9/25.
+//
+
+import DomainLayer
+
+extension PublicHex {
+	var cellCapacityReached: Bool {
+		guard let deviceCount, let capacity else {
+			return false
+		}
+
+		return deviceCount >= capacity
+	}
+}

PresentationLayer/Navigation/DeepLinkHandler.swift

@@ -239,8 +239,9 @@
 			let lon = cell.center.lon
 			let lat = cell.center.lat
 			let cellCenter = CLLocationCoordinate2D(latitude: lat, longitude: lon)
+			let cellCapacity = cell.capacity ?? 0
 
-			let route = Route.explorerList(ViewModelsFactory.getExplorerStationsListViewModel(cellIndex: index, cellCenter: cellCenter))
+			let route = Route.explorerList(ViewModelsFactory.getExplorerStationsListViewModel(cellIndex: index, cellCenter: cellCenter, cellCapacity: cellCapacity))
 			router.navigateTo(route)
 		}
 	}
@@ -254,7 +255,7 @@
 			case .weatherxmPro:
 				let viewModel = ViewModelsFactory.getProPromotionalViewModel()
 				router.showBottomSheet(.proPromo(viewModel))
 				break
 		}
 	}
 }

PresentationLayer/UIComponents/BaseComponents/SelectLocationMap/SelectLocationMapView.swift

@@ -19,7 +19,12 @@ struct SelectLocationMapView: View {
 									  annotationTitle: Binding(get: { viewModel.selectedDeviceLocation?.name },
 															   set: { _ in }),
 									  geometryProxyForFrameOfMapView: proxy.frame(in: .local),
-									  mapControls: viewModel.mapControls)
+									  polygonPoints: viewModel.explorerData?.cellCapacityPoints,
+									  polylinePoints: viewModel.explorerData?.cellBorderPoints,
+									  textPoints: viewModel.explorerData?.cellCapacityTextPoints,
+									  mapControls: viewModel.mapControls) { annotations in
+					viewModel.handlePointedAnnotationsChange(annotations: annotations)
+				}
 
 				searchArea
 			}
@@ -126,5 +131,6 @@ private extension SelectLocationMapView {
 
 #Preview {
 	let useCase = SwinjectHelper.shared.getContainerForSwinject().resolve(DeviceLocationUseCaseApi.self)!
-	return SelectLocationMapView(viewModel: .init(useCase: useCase))
+	let explorerUseCase = SwinjectHelper.shared.getContainerForSwinject().resolve(ExplorerUseCaseApi.self)!
+	return SelectLocationMapView(viewModel: .init(useCase: useCase, explorerUseCase: explorerUseCase))
 }

PresentationLayer/UIComponents/BaseComponents/SelectLocationMap/SelectLocationMapViewModel.swift

@@ -10,6 +10,7 @@
 import Combine
 import DomainLayer
 import Toolkit
+import MapboxMaps
 
 @MainActor
 protocol SelectLocationMapViewModelDelegate: AnyObject {
@@ -43,16 +44,26 @@
 		}
 	}
 	@Published private(set) var searchResults: [DeviceLocationSearchResult] = []
+	@Published private(set) var explorerData: ExplorerData?
 	var mapControls: MapControls = .init()
 	private var cancellableSet: Set<AnyCancellable> = .init()
 	private var latestTask: Cancellable?
+	private var latestPointedAnnotations: [PolygonAnnotation]?
 	let useCase: DeviceLocationUseCaseApi
+	let explorerUseCase: ExplorerUseCaseApi
 	weak var delegate: SelectLocationMapViewModelDelegate?
+	let linkNavigation: LinkNavigation
 
-	init(useCase: DeviceLocationUseCaseApi, initialCoordinate: CLLocationCoordinate2D? = nil, delegate: SelectLocationMapViewModelDelegate? = nil) {
+	init(useCase: DeviceLocationUseCaseApi,
+		 explorerUseCase: ExplorerUseCaseApi,
+		 initialCoordinate: CLLocationCoordinate2D? = nil,
+		 delegate: SelectLocationMapViewModelDelegate? = nil,
+		 linkNavigation: LinkNavigation = LinkNavigationHelper()) {
 		self.useCase = useCase
+		self.explorerUseCase = explorerUseCase
 		self.delegate = delegate
 		self.selectedCoordinate = initialCoordinate ?? useCase.getSuggestedDeviceLocation() ?? .init()
+		self.linkNavigation = linkNavigation
 		$selectedCoordinate
 			.debounce(for: 1.0, scheduler: DispatchQueue.main)
 			.sink { [weak self] _ in
@@ -70,6 +81,10 @@
 		useCase.searchResults.sink { [weak self] results in
 			self?.searchResults = results
 		}.store(in: &cancellableSet)
+
+		Task { @MainActor in
+			await getExplorerData()
+		}
 	}
 
 	func handleSearchResultTap(result: DeviceLocationSearchResult) {
@@ -105,6 +120,28 @@
 			}
 		}
 	}
+
+	func handlePointedAnnotationsChange(annotations: [PolygonAnnotation]) {
+		latestPointedAnnotations = annotations
+		let capacityReached = isPointedCellCapacityReached()
+
+		if capacityReached {
+			Toast.shared.show(text: LocalizableString.ClaimDevice.cellCapacityReachedMessage.localized.attributedMarkdown ?? "",
+							  type: .info,
+							  retryButtonTitle: LocalizableString.readMore.localized) { [weak self] in
+				self?.linkNavigation.openUrl(DisplayedLinks.cellCapacity.linkURL)
+			}
+		}
+	}
+
+	func isPointedCellCapacityReached() -> Bool {
+		guard let annotation = latestPointedAnnotations?.first,
+			  let count = annotation.userInfo?[ExplorerKeys.deviceCount.rawValue] as? Int,
+			  let capacity = annotation.userInfo?[ExplorerKeys.cellCapacity.rawValue] as? Int else {
+			return false
+		}
+		return count >= capacity
+	}
 }
 
 private extension SelectLocationMapViewModel {
@@ -116,4 +153,18 @@
 			self?.selectedDeviceLocation = location
 		}
 	}
+
+	func getExplorerData() async {
+		do {
+			let result = try await explorerUseCase.getPublicHexes()
+			switch result {
+				case .success(let hexes):
+					self.explorerData = ExplorerFactory(publicHexes: hexes).generateExplorerData()
+				case .failure(let error):
+					print(error)
+			}
+		} catch {
+			print(error)
+		}
+	}
 }

PresentationLayer/UIComponents/MapBox/MapBoxClaimDevice.swift

@@ -17,6 +17,10 @@
 	@Binding var location: CLLocationCoordinate2D
 	@Binding var annotationTitle: String?
 	let geometryProxyForFrameOfMapView: CGRect
+	let polygonPoints: [PolygonAnnotation]?
+	let polylinePoints: [PolylineAnnotation]?
+	let textPoints: [PointAnnotation]?
+	let annotationPointCallback: GenericMainActorCallback<[PolygonAnnotation]>
 
 	private let markerSize: CGSize = CGSize(width: 44.0, height: 44.0)
 	@State private var locationPoint: CGPoint = .zero
@@ -26,19 +30,31 @@
 	init(location: Binding<CLLocationCoordinate2D>,
 		 annotationTitle: Binding<String?>,
 		 geometryProxyForFrameOfMapView: CGRect,
-		 mapControls: MapControls) {
+		 polygonPoints: [PolygonAnnotation]?,
+		 polylinePoints: [PolylineAnnotation]?,
+		 textPoints: [PointAnnotation]?,
+		 mapControls: MapControls,
+		 annotationPointCallback: @escaping GenericMainActorCallback<[PolygonAnnotation]>) {
 		_location = location
 		_annotationTitle = annotationTitle
 		self.geometryProxyForFrameOfMapView = geometryProxyForFrameOfMapView
+		self.polygonPoints = polygonPoints
+		self.polylinePoints = polylinePoints
+		self.textPoints = textPoints
 		_controls = StateObject(wrappedValue: mapControls)
+		self.annotationPointCallback = annotationPointCallback
 	}
 
 	var body: some View {
 		ZStack {
 			MapBoxClaimDevice(location: $location,
 							  locationPoint: $locationPoint,
 							  geometryProxyForFrameOfMapView: geometryProxyForFrameOfMapView,
-							  controls: controls)
+							  polygonPoints: polygonPoints,
+							  polylinePoints: polylinePoints,
+							  textPoints: textPoints,
+							  controls: controls,
+							  annotationPointCallback: annotationPointCallback)
 
 			markerAnnotation
 				.offset(x: 0.0, y: markerAnnotationOffset)
@@ -90,9 +106,13 @@
     @Binding var location: CLLocationCoordinate2D
 	@Binding var locationPoint: CGPoint
     let geometryProxyForFrameOfMapView: CGRect
+	let polygonPoints: [PolygonAnnotation]?
+	let polylinePoints: [PolylineAnnotation]?
+	let textPoints: [PointAnnotation]?
 	@StateObject var controls: MapControls
+	let annotationPointCallback: GenericMainActorCallback<[PolygonAnnotation]>
 
-    func makeUIViewController(context _: Context) -> MapViewLocationController {
+    func makeUIViewController(context: Context) -> MapViewLocationController {
 		let controller = MapViewLocationController(frame: geometryProxyForFrameOfMapView,
 												   location: $location,
 												   locationPoint: $locationPoint)
@@ -109,11 +129,33 @@
 			controller?.setCenter(coordinate)
 		}
 
+		controller.delegate = context.coordinator
+
 		return controller
     }
 
+	func makeCoordinator() -> Coordinator {
+		Coordinator(annotationPointCallback: annotationPointCallback)
+	}
+
     func updateUIViewController(_ controller: MapViewLocationController, context _: Context) {
+		controller.polygonManager?.annotations = polygonPoints ?? []
+		controller.pointManager?.annotations = textPoints ?? []
+		controller.polylineManager?.annotations = polylinePoints ?? []
     }
+
+	class Coordinator: MapViewLocationControllerDelegate {
+		let annotationPointCallback: GenericMainActorCallback<[PolygonAnnotation]>
+
+		init(annotationPointCallback: @escaping GenericMainActorCallback<[PolygonAnnotation]>) {
+			self.annotationPointCallback = annotationPointCallback
+		}
+
+		@MainActor
+		func didPointAnnotations(_ annotations: [PolygonAnnotation]) {
+			annotationPointCallback(annotations)
+		}
+	}
 }
 
 class MapControls: ObservableObject {
@@ -122,16 +164,27 @@
 	var setMapCenter: GenericCallback<CLLocationCoordinate2D>?
 }
 
+@MainActor
+fileprivate protocol MapViewLocationControllerDelegate: AnyObject {
+	func didPointAnnotations(_ annotations: [PolygonAnnotation])
+}
+
 class MapViewLocationController: UIViewController {
     private static let ZOOM_LEVEL: CGFloat = 15
 
     let frame: CGRect
     @Binding var location: CLLocationCoordinate2D
 	@Binding var locationPoint: CGPoint
     internal var mapView: MapView!
+	internal weak var polygonManager: PolygonAnnotationManager?
+	internal weak var pointManager: PointAnnotationManager?
+	internal weak var polylineManager: PolylineAnnotationManager?
+	fileprivate weak var delegate: MapViewLocationControllerDelegate?
 	private var cancelablesSet = Set<AnyCancelable>()
 
-    init(frame: CGRect, location: Binding<CLLocationCoordinate2D>, locationPoint: Binding<CGPoint>) {
+    init(frame: CGRect,
+		 location: Binding<CLLocationCoordinate2D>,
+		 locationPoint: Binding<CGPoint>) {
         self.frame = frame
         _location = location
 		_locationPoint = locationPoint
@@ -157,6 +210,7 @@
         mapView.ornaments.options.scaleBar.visibility = .hidden
         mapView.gestures.options.rotateEnabled = false
         mapView.gestures.options.pitchEnabled = false
+
 		mapView.mapboxMap.setCamera(to: CameraOptions(zoom: 2))
 
 		mapView.translatesAutoresizingMaskIntoConstraints = false
@@ -173,6 +227,7 @@
 			}
 
 			self.locationPoint = self.mapView.mapboxMap.point(for: self.location)
+			self.updateLocationPointedAnnotations(self.locationPoint)
 		}.store(in: &cancelablesSet)
 
 		self.mapView.mapboxMap.onMapIdle.observe { [weak self] _ in
@@ -182,10 +237,13 @@
 				if let self = self {
 					self.location = pointAnnotation.point.coordinates
 					self.locationPoint = mapView.mapboxMap.point(for: self.location)
+					self.updateLocationPointedAnnotations(self.locationPoint)
 				}
 			}
 		}.store(in: &cancelablesSet)
 
+		setPolygonManagers()
+
 		setCenter(location)
     }
 
@@ -210,11 +268,68 @@
     internal func cameraSetup() -> CameraOptions {
         return CameraOptions(center: CLLocationCoordinate2D())
     }
+
+	func updateLocationPointedAnnotations(_ point: CGPoint) {
+		guard let polygonManager else {
+			return
+		}
+		let layerIds = [polygonManager.layerId]
+		let annotations = polygonManager.annotations
+		let options = RenderedQueryOptions(layerIds: layerIds, filter: nil)
+		mapView.mapboxMap.queryRenderedFeatures(with: point, options: options) { [weak self] result in
+			switch result {
+				case .success(let features):
+					let tappedAnnotations = annotations.filter { annotation in
+						features.contains(where: { feature in
+							guard let featureid = feature.queriedFeature.feature.identifier else {
+								return false
+							}
+							switch featureid {
+								case .string(let str):
+									return annotation.id == str
+								case .number(_):
+									return false
+							}
+						})
+					}
+
+					self?.delegate?.didPointAnnotations(tappedAnnotations)
+				case .failure(let error):
+					print(error)
+			}
+		}
+	}
 }
 
+
 extension MapViewLocationController {
     func locationUpdate(newLocation: Location) {
         mapView.mapboxMap.setCamera(to: CameraOptions(center: newLocation.coordinate, zoom: 13))
         location = newLocation.coordinate
     }
+
+	func setPolygonManagers() {
+		self.polygonManager = mapView.annotations.makePolygonAnnotationManager(id: MapBoxConstants.cellCapacityPolygonManagerId)
+		self.polylineManager = mapView.annotations.makePolylineAnnotationManager(id: MapBoxConstants.bordersManagerId)
+
+		let pointAnnotationManager = mapView.annotations.makePointAnnotationManager(id: MapBoxConstants.pointManagerId)
+		pointManager = pointAnnotationManager
+
+		try? mapView.mapboxMap.updateLayer(withId: MapBoxConstants.pointManagerId, type: SymbolLayer.self) { layer in
+			layer.minZoom = 10
+
+			let stops: [Double: Double] = [
+				10: CGFloat(.mediumFontSize),
+				12: CGFloat(.XLTitleFontSize),
+				16: CGFloat(.maxFontSize)
+			]
+
+			layer.textSize = .expression(Exp(.interpolate) {
+				Exp(.exponential) { 1.75 }
+				Exp(.zoom)
+				stops
+			})
+			layer.textColor = .constant(StyleColor(UIColor(colorEnum: .textWhite)))
+		}
+	}
 }

PresentationLayer/UIComponents/MapBox/MapBoxMapView.swift

@@ -86,11 +86,12 @@
 
         func didTapAnnotation(_: MapViewController, _ annotations: [PolygonAnnotation]) {
             guard let firstValidAnnotation = annotations.first,
-				  let hexIndex = firstValidAnnotation.userInfo?[ExplorerKeys.cellIndex.rawValue] as? String else {
+				  let hexIndex = firstValidAnnotation.userInfo?[ExplorerKeys.cellIndex.rawValue] as? String,
+				  let cellCapacity = firstValidAnnotation.userInfo?[ExplorerKeys.cellCapacity.rawValue] as? Int else {
 				return
 			}
 
-			viewModel.routeToDeviceListFor(hexIndex, firstValidAnnotation.polygon.center)
+			viewModel.routeToDeviceListFor(hexIndex, firstValidAnnotation.polygon.center, capacity: cellCapacity)
         }
 
         func didTapMapArea(_: MapViewController) {
@@ -201,7 +202,7 @@
 					case .failure(let error):
 						print(error)
 				}
 			}			
 		}.store(in: &cancelablesSet)
     }
 
@@ -210,7 +211,7 @@
         delegate?.configureMap(self)
     }
 
     internal func configureHeatMapLayer(source: GeoJSONSource) {
         layer.maxZoom = 10
         layer.heatmapColor = .expression(
             Exp(.interpolate) {