@pi-spi/app 0.0.0-stage → 1.2.1

package/src/modules/categorie/presentation/pages/categorie_form_pages.tsx

@@ -0,0 +1,206 @@
+import { MaterialIcons } from '@expo/vector-icons';
+import { Image } from 'expo-image';
+import type { ReactNode } from 'react';
+import { Pressable, ScrollView, StyleSheet, Text, View } from 'react-native';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+
+import { Images } from '../../../../core/assets';
+import { useBloc, useBlocBuilder, useBlocListener } from '../../../../core/bloc_react';
+import { AppRouter, useAppRouter } from '../../../../core/router';
+import { useTheme } from '../../../../core/theme';
+import { useAppLocalizations } from '../../../../l10n/localizations';
+import { ElevatedButton } from '../../../../shared/material/buttons';
+import { CustomTextInput } from '../../../../shared/widgets/input_text';
+import { Categorie } from '../../domain/models/categorie';
+import { CategorieCreateCommandError, CategorieUpdateCommandError } from '../../domain/models/categorie_commands';
+import { argbToCss } from '../../domain/models/categorie_icons';
+import { CategorieBloc } from '../bloc/categorie_bloc';
+import {
+  CategorieAddValidationEvent,
+  CategorieCreateEvent,
+  CategorieEditValidationEvent,
+  CategorieListEvent,
+  CategorieUpdateEvent,
+} from '../bloc/categorie_event';
+import { CategorieCreationState, CategorieEditState, CategorieInitialState } from '../bloc/categorie_state';
+import { CategorieEditIconBtn } from './categorie_edit_icon_btn';
+import { CategorieIcon } from './categorie_icon';
+
+/** Squelette commun : en-tête coloré (icône + titre + bouton icône), formulaire, bouton. */
+function CategorieFormLayout({
+  header,
+  title,
+  form,
+  button,
+}: {
+  header: ReactNode;
+  title: string;
+  form: ReactNode;
+  button: ReactNode;
+}) {
+  const theme = useTheme();
+  const insets = useSafeAreaInsets();
+  const categorieBloc = useBloc(CategorieBloc);
+  return (
+    <View style={[styles.flex, { backgroundColor: theme.secondaryHeaderColor }]}>
+      <View style={styles.backRow}>
+        <Pressable
+          accessibilityRole="button"
+          hitSlop={12}
+          style={styles.back}
+          onPress={() => categorieBloc.add(new CategorieListEvent())}
+        >
+          <MaterialIcons name="arrow-back" size={24} color={theme.colorScheme.onSurface} />
+        </Pressable>
+      </View>
+      {/* Icône et titre */}
+      <View style={styles.header}>
+        <View style={styles.center}>{header}</View>
+        <View style={styles.titleRow}>
+          <Text numberOfLines={1} style={[theme.textTheme.titleSmall, styles.flex]}>
+            {title}
+          </Text>
+          <CategorieEditIconBtn />
+        </View>
+      </View>
+      {/* Formulaire */}
+      <ScrollView style={[styles.flex, { backgroundColor: theme.scaffoldBackgroundColor }]} contentContainerStyle={styles.form}>
+        {form}
+      </ScrollView>
+      <View style={[styles.button, { backgroundColor: theme.scaffoldBackgroundColor, paddingBottom: 20 + insets.bottom }]}>
+        {button}
+      </View>
+    </View>
+  );
+}
+
+/** Création d'une catégorie personnalisée */
+export function CategorieAddPage() {
+  const traductions = useAppLocalizations();
+  const theme = useTheme();
+  const router = useAppRouter();
+  const categorieBloc = useBloc(CategorieBloc);
+  const state = useBlocBuilder(categorieBloc);
+  useBlocListener(categorieBloc, (s) => {
+    if (s instanceof CategorieInitialState) AppRouter.pop(router);
+  });
+  if (!(state instanceof CategorieCreationState)) return null;
+  const command = state.command;
+
+  return (
+    <CategorieFormLayout
+      header={<Image source={Images.categorie} style={styles.addIllustration} contentFit="contain" />}
+      title={traductions.categorieCustomAdd}
+      form={
+        <>
+          {/* Nom */}
+          <View style={styles.input}>
+            <CustomTextInput
+              labelText={traductions.categorieFormNameLabel}
+              value={command.label ?? ''}
+              messageError={
+                command.error != null && command.error !== CategorieCreateCommandError.empty
+                  ? command.error === CategorieCreateCommandError.invalid
+                    ? traductions.categorieFormNameInvalid
+                    : traductions.categorieFormNameAlready
+                  : ''
+              }
+              onChange={(value) => {
+                command.label = value;
+                categorieBloc.add(new CategorieAddValidationEvent(command));
+              }}
+            />
+          </View>
+          {/* Catégories suggérées */}
+          <View style={styles.chips}>
+            {Categorie.suggested.map((c) => (
+              <Pressable
+                key={c.id}
+                onPress={() => {
+                  command.label = c.label;
+                  command.icon = c.icon;
+                  command.color = c.bgColor;
+                  categorieBloc.add(new CategorieAddValidationEvent(command));
+                }}
+                style={[styles.chip, { backgroundColor: theme.secondaryHeaderColor, borderRadius: theme.chipTheme.borderRadius }]}
+              >
+                <Text style={theme.chipTheme.labelStyle}>{c.label}</Text>
+              </Pressable>
+            ))}
+          </View>
+        </>
+      }
+      button={
+        <ElevatedButton
+          onPress={() => {
+            if (command.isValid()) categorieBloc.add(new CategorieCreateEvent(command));
+          }}
+        >
+          {traductions.categorieFormCreateBtn}
+        </ElevatedButton>
+      }
+    />
+  );
+}
+
+/** Modification d'une catégorie personnalisée */
+export function CategorieEditPage() {
+  const traductions = useAppLocalizations();
+  const router = useAppRouter();
+  const categorieBloc = useBloc(CategorieBloc);
+  const state = useBlocBuilder(categorieBloc);
+  useBlocListener(categorieBloc, (s) => {
+    if (s instanceof CategorieInitialState) AppRouter.pop(router);
+  });
+  if (!(state instanceof CategorieEditState)) return null;
+  const { categorie, command } = state;
+
+  return (
+    <CategorieFormLayout
+      header={
+        <View style={[styles.editIcon, { backgroundColor: argbToCss(command.color) }]}>
+          <CategorieIcon icon={command.icon!} size={96} emojiSize={64} />
+        </View>
+      }
+      title={categorie.label}
+      form={
+        <View style={styles.input}>
+          <CustomTextInput
+            labelText={traductions.categorieFormNameLabel}
+            value={command.label ?? ''}
+            messageError={command.error === CategorieUpdateCommandError.invalid ? traductions.categorieFormNameInvalid : ''}
+            onChange={(value) => {
+              command.label = value;
+              categorieBloc.add(new CategorieEditValidationEvent(command, categorie));
+            }}
+          />
+        </View>
+      }
+      button={
+        <ElevatedButton
+          onPress={() => {
+            if (command.isValid()) categorieBloc.add(new CategorieUpdateEvent(command, categorie));
+          }}
+        >
+          {traductions.categorieFormSaveBtn}
+        </ElevatedButton>
+      }
+    />
+  );
+}
+
+const styles = StyleSheet.create({
+  flex: { flex: 1 },
+  backRow: { flexDirection: 'row' },
+  back: { padding: 12 },
+  header: { height: 200, paddingHorizontal: 20, paddingBottom: 20, justifyContent: 'space-between' },
+  center: { alignItems: 'center' },
+  titleRow: { flexDirection: 'row', alignItems: 'center' },
+  addIllustration: { width: 128, height: 110 },
+  editIcon: { borderRadius: 999, paddingVertical: 10, paddingHorizontal: 15, alignItems: 'center', justifyContent: 'center' },
+  form: { paddingHorizontal: 20, paddingBottom: 20 },
+  input: { paddingVertical: 20 },
+  chips: { flexDirection: 'row', flexWrap: 'wrap', gap: 8 },
+  chip: { paddingHorizontal: 12, paddingVertical: 8 },
+  button: { padding: 20 },
+});

package/src/modules/categorie/presentation/pages/categorie_icon.tsx

@@ -0,0 +1,38 @@
+import { Image } from 'expo-image';
+import { StyleSheet, Text, View } from 'react-native';
+
+import { argbToCss, categorieIconSource, isAssetIcon } from '../../domain/models/categorie_icons';
+
+/** Icône d'une catégorie (image ou emoji), éventuellement dans un cercle coloré. */
+export function CategorieIcon({
+  icon,
+  size,
+  emojiSize,
+  tintColor,
+}: {
+  icon: string;
+  size: number;
+  emojiSize?: number;
+  tintColor?: string;
+}) {
+  if (isAssetIcon(icon)) {
+    const source = categorieIconSource(icon);
+    if (source != null) {
+      return <Image source={source} style={{ width: size, height: size }} tintColor={tintColor} contentFit="contain" />;
+    }
+  }
+  return <Text style={{ fontSize: emojiSize ?? size * 0.8 }}>{icon}</Text>;
+}
+
+/** Pastille ronde de 45 px, fond à la couleur de la catégorie. */
+export function CategorieIconCircle({ icon, bgColor }: { icon: string; bgColor?: number }) {
+  return (
+    <View style={[styles.circle, { backgroundColor: argbToCss(bgColor) }]}>
+      <CategorieIcon icon={icon} size={25} emojiSize={20} />
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  circle: { width: 45, height: 45, borderRadius: 22.5, alignItems: 'center', justifyContent: 'center' },
+});

package/src/modules/categorie/presentation/pages/categorie_liste_widget.tsx

@@ -0,0 +1,83 @@
+import { MaterialIcons } from '@expo/vector-icons';
+import { useState } from 'react';
+import { Pressable, StyleSheet, Text, View } from 'react-native';
+
+import { useBloc } from '../../../../core/bloc_react';
+import { Themer, useTheme } from '../../../../core/theme';
+import { useAppLocalizations } from '../../../../l10n/localizations';
+import { TextButton } from '../../../../shared/material/buttons';
+import { Card } from '../../../../shared/material/card';
+import type { Categorie } from '../../domain/models/categorie';
+import { CategorieBloc } from '../bloc/categorie_bloc';
+import { CategorieEditEvent } from '../bloc/categorie_event';
+import { CategorieIconCircle } from './categorie_icon';
+
+/** Liste de catégories à cocher (avec bouton « Modifier » si [editable]). */
+export function CategorieListeWidget({
+  liste,
+  defaultSelectedCategories,
+  onSelectionChanged,
+  editable,
+}: {
+  liste: readonly Categorie[];
+  defaultSelectedCategories: string[];
+  onSelectionChanged: (categorie: Categorie, checked: boolean) => void;
+  editable?: boolean;
+}) {
+  const traductions = useAppLocalizations();
+  const theme = useTheme();
+  const categorieBloc = useBloc(CategorieBloc);
+  // Catégories sélectionnées
+  const [selected, setSelected] = useState<string[]>(() =>
+    liste.filter((c) => defaultSelectedCategories.includes(c.id)).map((c) => c.id),
+  );
+
+  return (
+    <Card>
+      <View style={styles.list}>
+        {liste.map((categorie) => {
+          const checked = selected.includes(categorie.id);
+          return (
+            <Pressable
+              key={categorie.id}
+              accessibilityRole="checkbox"
+              accessibilityState={{ checked }}
+              onPress={() => {
+                const value = !checked;
+                setSelected((s) => (value ? [...s, categorie.id] : s.filter((id) => id !== categorie.id)));
+                onSelectionChanged(categorie, value);
+              }}
+              style={styles.row}
+            >
+              <MaterialIcons
+                name={checked ? 'check-box' : 'check-box-outline-blank'}
+                size={24}
+                color={checked ? theme.colorScheme.primary : Themer.neural02Color}
+              />
+              <View style={styles.gap12} />
+              <CategorieIconCircle icon={categorie.icon} bgColor={categorie.bgColor} />
+              <View style={styles.gap12} />
+              {/* Libellé */}
+              <Text numberOfLines={1} style={[theme.textTheme.headlineSmall, styles.flex]}>
+                {` ${categorie.label}`}
+              </Text>
+              {/* Bouton modifier */}
+              {editable === true && (
+                <TextButton onPress={() => categorieBloc.add(new CategorieEditEvent(categorie))}>
+                  {traductions.categorieEditBtn}
+                </TextButton>
+              )}
+            </Pressable>
+          );
+        })}
+      </View>
+    </Card>
+  );
+}
+
+const styles = StyleSheet.create({
+  list: { paddingVertical: 8 },
+  row: { flexDirection: 'row', alignItems: 'center', paddingHorizontal: 16, paddingVertical: 8 },
+  gap12: { width: 12 },
+  flex: { flex: 1 },
+});

package/src/modules/categorie/presentation/pages/categorie_select_page.tsx

@@ -0,0 +1,105 @@
+import { MaterialIcons } from '@expo/vector-icons';
+import { Pressable, ScrollView, StyleSheet, Text, View } from 'react-native';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+
+import { useBloc, useBlocBuilder, useBlocListener } from '../../../../core/bloc_react';
+import { AppRouter, useAppRouter } from '../../../../core/router';
+import { Themer, useTheme } from '../../../../core/theme';
+import { useAppLocalizations } from '../../../../l10n/localizations';
+import { Card } from '../../../../shared/material/card';
+import { Divider } from '../../../../shared/material/divider';
+import { Categorie } from '../../domain/models/categorie';
+import { CategorieBloc } from '../bloc/categorie_bloc';
+import { CategorieAddEvent, CategorieListEvent } from '../bloc/categorie_event';
+import { CategorieCreationState, CategorieEditState, CategorieInitialState } from '../bloc/categorie_state';
+import { CategorieListeWidget } from './categorie_liste_widget';
+
+/** Choix d'une catégorie : la catégorie choisie est retournée à l'écran appelant. */
+export function CategorieSelectPage() {
+  const traductions = useAppLocalizations();
+  const theme = useTheme();
+  const router = useAppRouter();
+  const insets = useSafeAreaInsets();
+  const categorieBloc = useBloc(CategorieBloc);
+  const state = useBlocBuilder(categorieBloc);
+
+  useBlocListener(
+    categorieBloc,
+    (s) => {
+      if (s instanceof CategorieCreationState) void AppRouter.push(router, AppRouter.categoriesAdd);
+      else if (s instanceof CategorieEditState) void AppRouter.push(router, AppRouter.categoriesEdit);
+    },
+    (previous, current) =>
+      previous instanceof CategorieInitialState &&
+      (current instanceof CategorieCreationState || current instanceof CategorieEditState),
+  );
+
+  /** Lorsqu'une catégorie est cochée, la retourner */
+  const onSelected = (categorie: Categorie, checked: boolean) => {
+    if (checked) AppRouter.pop(router, { value: categorie });
+  };
+
+  return (
+    <View style={[styles.flex, { paddingBottom: insets.bottom }]}>
+      <View style={styles.backRow}>
+        <Pressable
+          accessibilityRole="button"
+          hitSlop={12}
+          style={styles.back}
+          onPress={() => {
+            categorieBloc.add(new CategorieListEvent());
+            AppRouter.pop(router);
+          }}
+        >
+          <MaterialIcons name="arrow-back" size={24} color={theme.colorScheme.onSurface} />
+        </Pressable>
+      </View>
+      <ScrollView contentContainerStyle={styles.content}>
+        {/* Catégories personnalisées */}
+        <Text style={theme.textTheme.headlineSmall}>{traductions.categorieCustomTitle}</Text>
+        <View style={styles.gap14} />
+        <Card>
+          {/* Bouton ajouter */}
+          <Pressable accessibilityRole="button" onPress={() => categorieBloc.add(new CategorieAddEvent())} style={styles.addRow}>
+            <View style={[styles.addIcon, { backgroundColor: theme.colorScheme.surface }]}>
+              <MaterialIcons name="add" size={24} color={theme.colorScheme.onSurface} />
+            </View>
+            <Text style={theme.textTheme.headlineSmall}>{traductions.categorieCustomAdd}</Text>
+          </Pressable>
+          {/* Catégories personnalisées */}
+          {state.categories.length > 0 && (
+            <>
+              <View style={styles.divider}>
+                <Divider color={Themer.neural01Color} />
+              </View>
+              <CategorieListeWidget
+                key={state.categories.map((c) => c.id + c.label).join()}
+                liste={state.categories}
+                editable
+                defaultSelectedCategories={[]}
+                onSelectionChanged={onSelected}
+              />
+            </>
+          )}
+        </Card>
+        <View style={styles.gap32} />
+        {/* Catégories par défaut */}
+        <Text style={theme.textTheme.headlineSmall}>{traductions.categorieDefaultTitle}</Text>
+        <View style={styles.gap14} />
+        <CategorieListeWidget liste={Categorie.defaultListe} defaultSelectedCategories={[]} onSelectionChanged={onSelected} />
+      </ScrollView>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  flex: { flex: 1 },
+  backRow: { flexDirection: 'row' },
+  back: { padding: 12 },
+  content: { paddingHorizontal: 12, paddingTop: 12 },
+  addRow: { flexDirection: 'row', alignItems: 'center', paddingHorizontal: 16, paddingVertical: 16, gap: 16 },
+  addIcon: { width: 45, height: 45, borderRadius: 14, alignItems: 'center', justifyContent: 'center' },
+  divider: { paddingHorizontal: 16 },
+  gap14: { height: 14 },
+  gap32: { height: 32 },
+});

package/src/modules/categorie/presentation/pages/categorie_select_widget.tsx

@@ -0,0 +1,38 @@
+import { StyleSheet, View } from 'react-native';
+
+import { useBloc, useBlocBuilder } from '../../../../core/bloc_react';
+import { Categorie } from '../../domain/models/categorie';
+import { CategorieBloc } from '../bloc/categorie_bloc';
+import { CategorieListeWidget } from './categorie_liste_widget';
+
+/** Sélection de catégories (personnalisées puis prédéfinies), utilisée par les filtres. */
+export function CategorieSelectWidget({
+  onSelectionChanged,
+  selectedCategories,
+}: {
+  onSelectionChanged: (categorie: Categorie, checked: boolean) => void;
+  selectedCategories: string[];
+}) {
+  const categorieBloc = useBloc(CategorieBloc);
+  const state = useBlocBuilder(categorieBloc);
+  return (
+    <View>
+      {/* Catégories personnalisées */}
+      <CategorieListeWidget
+        liste={state.categories}
+        editable={false}
+        defaultSelectedCategories={selectedCategories}
+        onSelectionChanged={onSelectionChanged}
+      />
+      <View style={styles.gap20} />
+      {/* Catégories par défaut */}
+      <CategorieListeWidget
+        liste={Categorie.defaultListe}
+        defaultSelectedCategories={selectedCategories}
+        onSelectionChanged={onSelectionChanged}
+      />
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({ gap20: { height: 20 } });

package/src/modules/compte/domain/exceptions/unknow_account_exception.ts

@@ -0,0 +1,10 @@
+/** Quand le numéro de compte est inconnu */
+export class UnknowAccountException extends Error {
+  readonly id: string;
+
+  constructor(params: { id: string; cause?: unknown }) {
+    super(`${params.id} <- ${params.cause}`);
+    this.id = params.id;
+    this.cause = params.cause;
+  }
+}

package/src/modules/compte/domain/models/compte.ts

@@ -0,0 +1,35 @@
+export class Compte {
+  participant: string;
+  other: string;
+  numero: string;
+  type: string;
+  dateOuverture: string;
+
+  constructor(params: { participant: string; other: string; numero: string; type: string; dateOuverture: string }) {
+    this.participant = params.participant;
+    this.other = params.other;
+    this.numero = params.numero;
+    this.type = params.type;
+    this.dateOuverture = params.dateOuverture;
+  }
+
+  static fromJson(json: Record<string, any>): Compte {
+    return new Compte({
+      participant: json.participant,
+      other: json.other,
+      numero: json.numero,
+      type: json.type,
+      dateOuverture: json.dateOuverture,
+    });
+  }
+
+  toJson(): Record<string, any> {
+    return {
+      participant: this.participant,
+      other: this.other,
+      numero: this.numero,
+      type: this.type,
+      dateOuverture: this.dateOuverture,
+    };
+  }
+}

package/src/modules/compte/domain/models/compte_alias.ts

@@ -0,0 +1,19 @@
+export class CompteAlias {
+  cle: string;
+  type: string;
+  shid?: string;
+
+  constructor(params: { cle: string; type: string; shid?: string }) {
+    this.cle = params.cle;
+    this.type = params.type;
+    this.shid = params.shid;
+  }
+
+  static fromJson(json: Record<string, any>): CompteAlias {
+    return new CompteAlias({ cle: json.cle, type: json.type, shid: 'shid' in json ? json.shid : undefined });
+  }
+
+  toJson(): Record<string, any> {
+    return { cle: this.cle, type: this.type, ...(this.shid != null ? { shid: this.shid } : {}) };
+  }
+}

package/src/modules/compte/domain/models/compte_details.ts

@@ -0,0 +1,17 @@
+import { Compte } from './compte';
+import { CompteAlias } from './compte_alias';
+
+export class CompteDetails {
+  constructor(
+    public compte: Compte,
+    public alias: CompteAlias,
+  ) {}
+
+  static fromJson(json: Record<string, any>): CompteDetails {
+    return new CompteDetails(Compte.fromJson(json.compte), CompteAlias.fromJson(json.alias));
+  }
+
+  toJson(): Record<string, any> {
+    return { compte: this.compte.toJson(), alias: this.alias.toJson() };
+  }
+}

package/src/modules/compte/domain/services/compte_service.ts

@@ -0,0 +1,31 @@
+import type { Stream } from '../../../../core/stream';
+import type { CompteInputPort } from '../../ports/input/compte_input_port';
+import type { CompteOutputPort } from '../../ports/output/compte_output_port';
+import type { CompteDetails } from '../models/compte_details';
+
+export class CompteService implements CompteInputPort {
+  /** [compteOutputPort] : port d'accès aux données des comptes */
+  constructor(readonly compteOutputPort: CompteOutputPort) {}
+
+  getSolde(id: string): Promise<Stream<number | null>> {
+    return this.compteOutputPort.getSolde(id);
+  }
+
+  fetchSolde(id: string): Promise<number> {
+    return this.compteOutputPort.fetchSolde(id);
+  }
+
+  /** Recuperer les informations du compte identifié sur le serveur */
+  getDetails(compte: string): Promise<CompteDetails> {
+    return this.compteOutputPort.getDetails(compte);
+  }
+
+  /** Recuperer les informations du compte identifié en local */
+  fetchDetails(compte: string): Promise<CompteDetails | null> {
+    return this.compteOutputPort.fetchDetails(compte);
+  }
+
+  modifierSolde(compteId: string, solde: number): Promise<void> {
+    return this.compteOutputPort.modifierSolde(compteId, solde);
+  }
+}

package/src/modules/compte/infra/compte_entity.ts

@@ -0,0 +1,22 @@
+import { CompteDetails } from '../domain/models/compte_details';
+
+export class CompteEntity {
+  solde?: number | null;
+  details?: CompteDetails | null;
+
+  constructor(params: { solde?: number | null; details?: CompteDetails | null } = {}) {
+    this.solde = params.solde;
+    this.details = params.details;
+  }
+
+  static fromJson(json: Record<string, any>): CompteEntity {
+    return new CompteEntity({
+      details: json.details != null ? CompteDetails.fromJson(json.details) : null,
+      solde: json.solde != null ? parseFloat(String(json.solde)) : 0,
+    });
+  }
+
+  toJson(): Record<string, any> {
+    return { details: this.details?.toJson() ?? null, solde: this.solde != null ? String(this.solde) : null };
+  }
+}

package/src/modules/compte/infra/compte_output_local.ts

@@ -0,0 +1,38 @@
+import { AppStorage } from '../../../core/storage';
+import type { CompteDetails } from '../domain/models/compte_details';
+import { CompteEntity } from './compte_entity';
+
+export class CompteOutputLocal {
+  static readonly collectionId = 'compte';
+
+  /** Solde du compte */
+  async enregistrerSolde(compteId: string, solde: number): Promise<void> {
+    const compte = (await this.entity(compteId)) ?? new CompteEntity();
+    compte.solde = solde;
+    await AppStorage.save(CompteOutputLocal.collectionId, compteId, compte.toJson());
+  }
+
+  /** Details du compte */
+  async enregistrerDetails(compteId: string, compteDetails: CompteDetails): Promise<void> {
+    const compte = (await this.entity(compteId)) ?? new CompteEntity();
+    compte.details = compteDetails;
+    await AppStorage.save(CompteOutputLocal.collectionId, compteId, compte.toJson());
+  }
+
+  /** Recuperer le dernier solde enregistré */
+  async getSolde(id: string): Promise<number | null> {
+    const json = await AppStorage.get(CompteOutputLocal.collectionId, id, (j) => j);
+    if (json == null) return null;
+    const solde = parseFloat(String(json.solde));
+    return Number.isNaN(solde) ? null : solde;
+  }
+
+  /** Recuperer les details du compte */
+  async getDetails(compteId: string): Promise<CompteDetails | null> {
+    return (await this.entity(compteId))?.details ?? null;
+  }
+
+  private entity(compteId: string): Promise<CompteEntity | null> {
+    return AppStorage.get(CompteOutputLocal.collectionId, compteId, (json) => CompteEntity.fromJson(json));
+  }
+}