feat(smart-app): implement complete mobile app MVP

- App.tsx: full navigation (Auth stack + Main tabs with 5 screens)
- Auth: LoginScreen, RegisterScreen, ForgotPasswordScreen
- HomeScreen: dashboard with IoT metrics, weather widget, alerts, quick actions, sensors
- MapScreen: interactive map with layer toggles (6 layers)
- MarketplaceScreen: categories (6), products (5), search
- ChatScreen: AI chat with quick prompts (4), bot responses
- ProfileScreen: user info, stats, menu (9 items), logout
- AlertsScreen: alert list with severity, acknowledge
- SensorsScreen: sensor list with type filters (6 types), search
- ZonesScreen: zone cards with stats
- SettingsScreen: language picker (FR/EN/ES/DE), privacy, about
- Stores: iotStore (sensors, zones, alerts), notificationStore, uiStore + i18n
- Hooks: useSensors, useAlerts, useNotifications, useLocation
- Components: Card, Button, LoadingSpinner, ErrorBoundary, Header
- Services: iotService, notificationService (with axios API client)
- Utils: formatters (temp, AQI, noise, dates), validators (email, password, IBAN)
- Theme: colors.ts with full design system (Blue Ocean palette)
- Ditto: fixed MongoDB connection, new JWT secrets, official gateway image

smart-app-city/frontend/node_modules/expo-notifications/ios/EXNotifications/Permissions/EXLegacyRemoteNotificationPermissionRequester.h

@@ -0,0 +1,13 @@
+// Copyright 2016-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXPermissionsInterface.h>
+#import <EXNotifications/EXRemoteNotificationPermissionSingletonModule.h>
+
+// TODO: Remove once we deprecate and remove "notifications" permission type
+@interface EXLegacyRemoteNotificationPermissionRequester : NSObject <EXPermissionsRequester, EXRemoteNotificationPermissionDelegate>
+
+- (instancetype)initWithUserNotificationPermissionRequester:(id<EXPermissionsRequester>)userNotificationPermissionRequester
+                                        permissionPublisher:(id<EXRemoteNotificationPermissionProgressPublisher>)permissionProgressPublisher
+                                            withMethodQueue:(dispatch_queue_t)methodQueue;
+
+@end

smart-app-city/frontend/node_modules/expo-notifications/ios/EXNotifications/Permissions/EXLegacyRemoteNotificationPermissionRequester.m

@@ -0,0 +1,135 @@
+// Copyright 2016-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXLegacyRemoteNotificationPermissionRequester.h>
+#import <ExpoModulesCore/EXUtilities.h>
+
+@interface EXLegacyRemoteNotificationPermissionRequester ()
+
+@property (nonatomic, strong) EXPromiseResolveBlock resolve;
+@property (nonatomic, strong) EXPromiseRejectBlock reject;
+@property (nonatomic, assign) BOOL remoteNotificationsRegistrationIsPending;
+@property (nonatomic, weak) id<EXPermissionsRequester> userNotificationPermissionRequester;
+@property (nonatomic, weak) dispatch_queue_t methodQueue;
+@property (nonatomic, weak) id<EXRemoteNotificationPermissionProgressPublisher> permissionProgressPublisher;
+
+@end
+
+@implementation EXLegacyRemoteNotificationPermissionRequester
+
++ (NSString *)permissionType
+{
+  return @"notifications";
+}
+
+- (instancetype)initWithUserNotificationPermissionRequester:(id<EXPermissionsRequester>)userNotificationPermissionRequester
+                                        permissionPublisher:(id<EXRemoteNotificationPermissionProgressPublisher>)permissionProgressPublisher
+                                            withMethodQueue:(dispatch_queue_t)methodQueue
+{
+  if (self = [super init]) {
+    _remoteNotificationsRegistrationIsPending = NO;
+    _permissionProgressPublisher = permissionProgressPublisher;
+    _userNotificationPermissionRequester = userNotificationPermissionRequester;
+    _methodQueue = methodQueue;
+  }
+  return self;
+}
+
+- (NSDictionary *)getPermissions
+{
+  __block EXPermissionStatus status;
+  [EXUtilities performSynchronouslyOnMainThread:^{
+    status = (UMSharedApplication().isRegisteredForRemoteNotifications) ?
+    EXPermissionStatusGranted :
+    EXPermissionStatusUndetermined;
+  }];
+  NSMutableDictionary *permissions = [[_userNotificationPermissionRequester getPermissions] mutableCopy];
+  
+  [permissions setValuesForKeysWithDictionary:@{
+                                                @"status": @(status),
+
+                                                }];
+  return permissions;
+}
+
+- (void)requestPermissionsWithResolver:(EXPromiseResolveBlock)resolve rejecter:(EXPromiseRejectBlock)reject
+{
+  if (_resolve != nil || _reject != nil) {
+    reject(@"E_AWAIT_PROMISE", @"Another request for the same permission is already being handled.", nil);
+    return;
+  }
+
+  _resolve = resolve;
+  _reject = reject;
+
+  BOOL __block isRegisteredForRemoteNotifications = NO;
+  [EXUtilities performSynchronouslyOnMainThread:^{
+    isRegisteredForRemoteNotifications = UMSharedApplication().isRegisteredForRemoteNotifications;
+  }];
+
+  if (isRegisteredForRemoteNotifications) {
+    // resolve immediately if already registered
+    [self _maybeConsumeResolverWithCurrentPermissions];
+  } else {
+    [_permissionProgressPublisher addDelegate:self];
+     EX_WEAKIFY(self)
+    [_userNotificationPermissionRequester requestPermissionsWithResolver:^(NSDictionary *permission){
+      EX_STRONGIFY(self)
+      EXPermissionStatus localNotificationsStatus = [[permission objectForKey:@"status"] intValue];
+      // We may assume that `EXLocalNotificationRequester`'s permission request will always finish
+      // when the user responds to the dialog or has already responded in the past.
+      // However, `UIApplication.registerForRemoteNotification` results in calling
+      // `application:didRegisterForRemoteNotificationsWithDeviceToken:` or
+      // `application:didFailToRegisterForRemoteNotificationsWithError:` on the application delegate
+      // ONLY when the notifications are enabled in settings (by allowing sound, alerts or app badge).
+      // So, when the local notifications are disabled, the application delegate's callbacks will not be called instantly.
+      if (localNotificationsStatus == EXPermissionStatusDenied) {
+        [self _clearObserver];
+        [self _maybeConsumeResolverWithCurrentPermissions];
+      } else {
+        self.remoteNotificationsRegistrationIsPending = YES;
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [UMSharedApplication() registerForRemoteNotifications];
+        });
+      }
+    } rejecter:^(NSString *code, NSString *message, NSError *error){
+      [self _clearObserver];
+      if (self.reject) {
+        self.reject(code, message, error);
+      }
+    }];
+  }
+}
+
+- (void)dealloc
+{
+  [self _clearObserver];
+}
+
+- (void)handleDidFinishRegisteringForRemoteNotifications
+{
+  [self _clearObserver];
+  EX_WEAKIFY(self)
+  dispatch_async(_methodQueue, ^{
+    EX_STRONGIFY(self)
+    [self _maybeConsumeResolverWithCurrentPermissions];
+  });
+}
+
+- (void)_clearObserver
+{
+  [_permissionProgressPublisher removeDelegate:self];
+  _remoteNotificationsRegistrationIsPending = NO;
+}
+
+- (void)_maybeConsumeResolverWithCurrentPermissions
+{
+  if (!_remoteNotificationsRegistrationIsPending) {
+    if (_resolve) {
+      _resolve([self getPermissions]);
+      _resolve = nil;
+      _reject = nil;
+    }
+  }
+}
+
+@end

smart-app-city/frontend/node_modules/expo-notifications/ios/EXNotifications/Permissions/EXNotificationPermissionsModule.h

@@ -0,0 +1,8 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXExportedModule.h>
+#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
+
+@interface EXNotificationPermissionsModule : EXExportedModule <EXModuleRegistryConsumer>
+
+@end

smart-app-city/frontend/node_modules/expo-notifications/ios/EXNotifications/Permissions/EXNotificationPermissionsModule.m

@@ -0,0 +1,67 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXNotificationPermissionsModule.h>
+
+#import <ExpoModulesCore/EXPermissionsInterface.h>
+#import <ExpoModulesCore/EXPermissionsMethodsDelegate.h>
+
+#import <EXNotifications/EXLegacyRemoteNotificationPermissionRequester.h>
+#import <EXNotifications/EXUserFacingNotificationsPermissionsRequester.h>
+
+@interface EXNotificationPermissionsModule ()
+
+@property (nonatomic, weak) id<EXPermissionsInterface> permissionsManager;
+@property (nonatomic, strong) EXUserFacingNotificationsPermissionsRequester *requester;
+@property (nonatomic, strong) EXLegacyRemoteNotificationPermissionRequester *legacyRemoteNotificationsRequester;
+
+@end
+
+@implementation EXNotificationPermissionsModule
+
+EX_EXPORT_MODULE(ExpoNotificationPermissionsModule);
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _requester = [[EXUserFacingNotificationsPermissionsRequester alloc] initWithMethodQueue:self.methodQueue];
+  }
+  return self;
+}
+
+# pragma mark - Exported methods
+
+EX_EXPORT_METHOD_AS(getPermissionsAsync,
+                    getPermissionsAsync:(EXPromiseResolveBlock)resolve
+                    rejecter:(EXPromiseRejectBlock)reject)
+{
+  [EXPermissionsMethodsDelegate getPermissionWithPermissionsManager:_permissionsManager
+                                                      withRequester:[EXUserFacingNotificationsPermissionsRequester class]
+                                                            resolve:resolve
+                                                             reject:reject];
+}
+
+EX_EXPORT_METHOD_AS(requestPermissionsAsync,
+                    requestPermissionsAsync:(NSDictionary *)requestedPermissions
+                    requester:(EXPromiseResolveBlock)resolve
+                    rejecter:(EXPromiseRejectBlock)reject)
+{
+  [EXUserFacingNotificationsPermissionsRequester setRequestedPermissions:requestedPermissions];
+  [EXPermissionsMethodsDelegate askForPermissionWithPermissionsManager:_permissionsManager
+                                                         withRequester:[EXUserFacingNotificationsPermissionsRequester class]
+                                                               resolve:resolve
+                                                                reject:reject];
+}
+
+# pragma mark - EXModuleRegistryConsumer
+
+- (void)setModuleRegistry:(EXModuleRegistry *)moduleRegistry {
+  _permissionsManager = [moduleRegistry getModuleImplementingProtocol:@protocol(EXPermissionsInterface)];
+  if (!_legacyRemoteNotificationsRequester) {
+    // TODO: Remove once we deprecate and remove "notifications" permission type
+    _legacyRemoteNotificationsRequester = [[EXLegacyRemoteNotificationPermissionRequester alloc] initWithUserNotificationPermissionRequester:_requester permissionPublisher:[moduleRegistry getSingletonModuleForName:@"RemoteNotificationPermissionPublisher"] withMethodQueue:self.methodQueue];
+  }
+  [EXPermissionsMethodsDelegate registerRequesters:@[_requester, _legacyRemoteNotificationsRequester]
+                            withPermissionsManager:_permissionsManager];
+}
+
+@end

smart-app-city/frontend/node_modules/expo-notifications/ios/EXNotifications/Permissions/EXRemoteNotificationPermissionSingletonModule.h

@@ -0,0 +1,29 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <ExpoModulesCore/EXSingletonModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol EXRemoteNotificationPermissionDelegate
+
+- (void)handleDidFinishRegisteringForRemoteNotifications;
+
+@end
+
+@protocol EXRemoteNotificationPermissionProgressPublisher
+
+- (void)addDelegate:(id<EXRemoteNotificationPermissionDelegate>)delegate;
+- (void)removeDelegate:(id<EXRemoteNotificationPermissionDelegate>)delegate;
+
+@end
+
+@interface EXRemoteNotificationPermissionSingletonModule : EXSingletonModule <UIApplicationDelegate, EXRemoteNotificationPermissionProgressPublisher>
+
+- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)token;
+- (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/expo-notifications/ios/EXNotifications/Permissions/EXRemoteNotificationPermissionSingletonModule.m

@@ -0,0 +1,68 @@
+
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXRemoteNotificationPermissionSingletonModule.h>
+#import <ExpoModulesCore/EXDefines.h>
+
+@interface EXRemoteNotificationPermissionSingletonModule ()
+
+@property (nonatomic, strong) NSPointerArray *delegates;
+
+@end
+
+@implementation EXRemoteNotificationPermissionSingletonModule
+
+EX_REGISTER_SINGLETON_MODULE(RemoteNotificationPermissionPublisher);
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _delegates = [NSPointerArray weakObjectsPointerArray];
+  }
+  return self;
+}
+
+# pragma mark - UIApplicationDelegate
+
+- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)token
+{
+  // Copying the array in case delegates remove themselves while handling the "did finish" event
+  NSPointerArray *immutableDelegates = [_delegates copy];
+  for (int i = 0; i < immutableDelegates.count; i++) {
+    id pointer = [immutableDelegates pointerAtIndex:i];
+    [pointer handleDidFinishRegisteringForRemoteNotifications];
+  }
+}
+
+- (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error
+{
+  // Copying the array in case delegates remove themselves while handling the "did finish" event
+  NSPointerArray *immutableDelegates = [_delegates copy];
+  for (int i = 0; i < immutableDelegates.count; i++) {
+    id pointer = [_delegates pointerAtIndex:i];
+    [pointer handleDidFinishRegisteringForRemoteNotifications];
+  }
+}
+
+# pragma mark - EXNotificationCenterDelegate
+
+- (void)addDelegate:(id<EXRemoteNotificationPermissionDelegate>)delegate
+{
+  [_delegates addPointer:(__bridge void * _Nullable)(delegate)];
+}
+
+- (void)removeDelegate:(id<EXRemoteNotificationPermissionDelegate>)delegate
+{
+  for (int i = 0; i < _delegates.count; i++) {
+    id pointer = [_delegates pointerAtIndex:i];
+    if (pointer == (__bridge void * _Nullable)(delegate) || !pointer) {
+      [_delegates removePointerAtIndex:i];
+      i--;
+    }
+  }
+  // compact doesn't work, that's why we need the `|| !pointer` above
+  // http://www.openradar.me/15396578
+  [_delegates compact];
+}
+
+@end

smart-app-city/frontend/node_modules/expo-notifications/ios/EXNotifications/Permissions/EXUserFacingNotificationsPermissionsRequester.h

@@ -0,0 +1,15 @@
+// Copyright 2019-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXPermissionsInterface.h>
+
+@interface EXUserFacingNotificationsPermissionsRequester : NSObject <EXPermissionsRequester>
+
+- (instancetype)initWithMethodQueue:(dispatch_queue_t)methodQueue;
+
+- (void)requestPermissions:(NSDictionary *)permissions
+              withResolver:(EXPromiseResolveBlock)resolve
+                  rejecter:(EXPromiseRejectBlock)reject;
+
++ (void)setRequestedPermissions:(NSDictionary *)permissions;
+
+@end

smart-app-city/frontend/node_modules/expo-notifications/ios/EXNotifications/Permissions/EXUserFacingNotificationsPermissionsRequester.m

@@ -0,0 +1,202 @@
+// Copyright 2019-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXUserFacingNotificationsPermissionsRequester.h>
+#import <ExpoModulesCore/EXDefines.h>
+#import <UserNotifications/UserNotifications.h>
+
+@interface EXUserFacingNotificationsPermissionsRequester ()
+
+@property (nonatomic, assign) dispatch_queue_t methodQueue;
+
+@end
+
+@implementation EXUserFacingNotificationsPermissionsRequester
+
+static NSDictionary *_requestedPermissions;
+
++ (NSString *)permissionType
+{
+  return @"userFacingNotifications";
+}
+
+- (instancetype)initWithMethodQueue:(dispatch_queue_t)methodQueue
+{
+  if (self = [super init]) {
+    _methodQueue = methodQueue;
+  }
+  return self;
+}
+
+- (NSDictionary *)getPermissions
+{
+  dispatch_assert_queue_not(dispatch_get_main_queue());
+  dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+
+  __block NSMutableDictionary *status = [NSMutableDictionary dictionary];
+  __block EXPermissionStatus generalStatus = EXPermissionStatusUndetermined;
+
+  [[UNUserNotificationCenter currentNotificationCenter] getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings *settings) {
+    if (settings.authorizationStatus == UNAuthorizationStatusAuthorized) {
+      generalStatus = EXPermissionStatusGranted;
+    } else if (settings.authorizationStatus == UNAuthorizationStatusDenied) {
+      generalStatus = EXPermissionStatusDenied;
+    }
+
+    status[@"status"] = [self authorizationStatusToEnum:settings.authorizationStatus];
+
+    status[@"allowsDisplayInNotificationCenter"] = [self notificationSettingToNumber:settings.notificationCenterSetting] ?: [NSNull null];
+    status[@"allowsDisplayOnLockScreen"] = [self notificationSettingToNumber:settings.lockScreenSetting] ?: [NSNull null];
+    status[@"allowsDisplayInCarPlay"] = [self notificationSettingToNumber:settings.carPlaySetting] ?: [NSNull null];
+
+    status[@"allowsAlert"] = [self notificationSettingToNumber:settings.alertSetting] ?: [NSNull null];
+    status[@"allowsBadge"] = [self notificationSettingToNumber:settings.badgeSetting] ?: [NSNull null];
+    status[@"allowsSound"] = [self notificationSettingToNumber:settings.soundSetting] ?: [NSNull null];
+
+    if (@available(iOS 12.0, *)) {
+      status[@"allowsCriticalAlerts"] = [self notificationSettingToNumber:settings.criticalAlertSetting] ?: [NSNull null];
+    }
+
+    status[@"alertStyle"] = [self alertStyleToEnum:settings.alertStyle];
+    status[@"allowsPreviews"] = [self showPreviewsSettingToEnum:settings.showPreviewsSetting];
+    if (@available(iOS 12.0, *)) {
+      status[@"providesAppNotificationSettings"] = @(settings.providesAppNotificationSettings);
+    }
+
+    if (@available(iOS 13.0, *)) {
+      status[@"allowsAnnouncements"] = [self notificationSettingToNumber:settings.announcementSetting] ?: [NSNull null];
+    }
+
+    dispatch_semaphore_signal(sem);
+  }];
+
+  dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+
+  return @{
+           @"status": @(generalStatus),
+           @"ios": status
+           };
+}
+
+- (void)requestPermissionsWithResolver:(EXPromiseResolveBlock)resolve rejecter:(EXPromiseRejectBlock)reject
+{
+  if (!_requestedPermissions || [_requestedPermissions count] == 0) {
+    _requestedPermissions = @{
+                              @"allowAlert": @(YES),
+                              @"allowBadge": @(YES),
+                              @"allowSound": @(YES)
+                            };
+  }
+  [self requestPermissions:_requestedPermissions withResolver:resolve rejecter:reject];
+}
+
+- (void)requestPermissions:(NSDictionary *)permissions withResolver:(EXPromiseResolveBlock)resolve rejecter:(EXPromiseRejectBlock)reject
+{
+  UNAuthorizationOptions options = UNAuthorizationOptionNone;
+  if ([permissions[@"allowAlert"] boolValue]) {
+    options |= UNAuthorizationOptionAlert;
+  }
+  if ([permissions[@"allowBadge"] boolValue]) {
+    options |= UNAuthorizationOptionBadge;
+  }
+  if ([permissions[@"allowSound"] boolValue]) {
+    options |= UNAuthorizationOptionSound;
+  }
+  if ([permissions[@"allowDisplayInCarPlay"] boolValue]) {
+    options |= UNAuthorizationOptionCarPlay;
+  }
+  if (@available(iOS 12.0, *)) {
+    if ([permissions[@"allowCriticalAlerts"] boolValue]) {
+        options |= UNAuthorizationOptionCriticalAlert;
+    }
+    if ([permissions[@"provideAppNotificationSettings"] boolValue]) {
+        options |= UNAuthorizationOptionProvidesAppNotificationSettings;
+    }
+    if ([permissions[@"allowProvisional"] boolValue]) {
+        options |= UNAuthorizationOptionProvisional;
+    }
+  }
+  if (@available(iOS 13.0, *)) {
+    if ([permissions[@"allowAnnouncements"] boolValue]) {
+      options |= UNAuthorizationOptionAnnouncement;
+    }
+  }
+  [self requestAuthorizationOptions:options withResolver:resolve rejecter:reject];
+}
+
+- (void)requestAuthorizationOptions:(UNAuthorizationOptions)options withResolver:(EXPromiseResolveBlock)resolve rejecter:(EXPromiseRejectBlock)reject
+{
+  EX_WEAKIFY(self);
+  [[UNUserNotificationCenter currentNotificationCenter] requestAuthorizationWithOptions:options completionHandler:^(BOOL granted, NSError * _Nullable error) {
+    EX_STRONGIFY(self);
+    // getPermissions blocks method queue on which this callback is being executed
+    // so we have to dispatch to another queue.
+    dispatch_async(self.methodQueue, ^{
+      if (error) {
+        reject(@"ERR_PERMISSIONS_REQUEST_NOTIFICATIONS", error.description, error);
+      } else {
+        resolve([self getPermissions]);
+      }
+    });
+  }];
+}
+
+# pragma mark - Utilities - notification settings to string
+
+- (NSNumber *)showPreviewsSettingToEnum:(UNShowPreviewsSetting)setting {
+  switch (setting) {
+    case UNShowPreviewsSettingNever:
+      return @(0);
+    case UNShowPreviewsSettingAlways:
+      return @(1);
+    case UNShowPreviewsSettingWhenAuthenticated:
+      return @(2);
+  }
+}
+
+- (NSNumber *)alertStyleToEnum:(UNAlertStyle)style {
+  switch (style) {
+    case UNAlertStyleNone:
+      return @(0);
+    case UNAlertStyleBanner:
+      return @(1);
+    case UNAlertStyleAlert:
+      return @(2);
+  }
+}
+
+- (NSNumber *)authorizationStatusToEnum:(UNAuthorizationStatus)status
+{
+  switch (status) {
+    case UNAuthorizationStatusNotDetermined:
+      return @(0);
+    case UNAuthorizationStatusDenied:
+      return @(1);
+    case UNAuthorizationStatusAuthorized:
+      return @(2);
+    case UNAuthorizationStatusProvisional:
+      return @(3);
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000
+    case UNAuthorizationStatusEphemeral:
+      return @(4);
+#endif
+  }
+}
+
+- (nullable NSNumber *)notificationSettingToNumber:(UNNotificationSetting)setting
+{
+  switch (setting) {
+    case UNNotificationSettingEnabled:
+      return @(YES);
+    case UNNotificationSettingDisabled:
+      return @(NO);
+    case UNNotificationSettingNotSupported:
+      return nil;
+  }
+}
+
++ (void)setRequestedPermissions:(NSDictionary *)permissions
+{
+  _requestedPermissions = permissions;
+}
+
+@end