/ - Diff - GES_PAC - Forge DGA

     using GES_PAC.Model;
     using GES_PAC.ViewModel;
     using Microsoft.EntityFrameworkCore;
     namespace GES_PAC
+    {
         public partial class App : Application
+        {
             public static AppDbContext Db { get; private set; }
             public App()
+            {
                 InitializeComponent();
                 //var dbPath = Path.Combine(FileSystem.AppDataDirectory, "GES_PAC.db3");
                 //if (File.Exists(dbPath))
                 //    File.Delete(dbPath);
                 Db = new AppDbContext();
                 Db.Database.EnsureCreated();
                 _ = InitSmartEnumsAsync();
                 //_ = InitDb();
+            }
             protected override Window CreateWindow(IActivationState? activationState)
+            {
                 return new Window(new AppShell());
+            }
             public static async Task InitSmartEnumsAsync()
+            {
                 foreach (var phase in PhaseCalibration.All)
+                {
                     if (!await Db.PhaseCalibration.AnyAsync(p => p.Value == phase.Value))
                         Db.PhaseCalibration.Add(phase);
+                }
                 foreach (var type in TypeCalibration.All)
+                {
                     if (!await Db.TypeCalibration.AnyAsync(t => t.Value == type.Value))
                         Db.TypeCalibration.Add(type);
+                }
                 foreach (var comportement in TypeComportement.All)
+                {
                     if (!await Db.TypeComportement.AnyAsync(c => c.Value == comportement.Value))
                         Db.TypeComportement.Add(comportement);
+                }
                 await Db.SaveChangesAsync();
+            }
             private async Task InitDb()
+            {
                 //ONLY FOR TESTS
                 var place = new Lieu("Elevage Langlade", "INRAE", "Mouton");
                 var person = new Personne("Bond", "James", "jamesbond@inrae.fr");
                 await Db.Personne.AddAsync(person);
                 await Db.Lieu.AddAsync(place);
                 await Db.SaveChangesAsync();
                 //ONLY FOR TESTS
+            }
+        }
+    }

     		<SingleProject>true</SingleProject>
     		<ImplicitUsings>enable</ImplicitUsings>
     		<Nullable>enable</Nullable>
     		<GenerateSatelliteAssemblies>false</GenerateSatelliteAssemblies>
     		<!-- Display name -->
     		<ApplicationTitle>GES_PAC</ApplicationTitle>
-...
     	<ItemGroup>
     		<PackageReference Include="CommunityToolkit.Maui" Version="9.1.1" />
     		<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.4" />
     		<PackageReference Include="Microsoft.Maui.Controls" Version="$(MauiVersion)" />
     		<PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="9.0.0" />
     		<PackageReference Include="sqlite-net-pcl" Version="1.9.172" />
     	</ItemGroup>
     	<ItemGroup>

     using SQLite;
     using System.ComponentModel.DataAnnotations.Schema;
     namespace GES_PAC.Model
+    {
         public class Calibration
+        {
             public long Id { get; set; }
             #region Propri?t?s
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public int PhaseCalibrationId { get; set; }
             [ForeignKey("PhaseCalibrationId")]
             public PhaseCalibration Phase { get; set; }
             public List<MesureCalibration> Mesures { get; set; }
             public List<MesureCalibration> Mesures { get; set; } = [];
             public int JourneeId { get; set; }
             [ForeignKey("JourneeId")]
             public Journee Journee { get; set; }
             #endregion
             #region Constructeurs
             public Calibration() { }
             public Calibration(PhaseCalibration Phase, MesureCalibration Mesure)
+            {
                 this.Phase = Phase;
                 Mesures = [];
                 Mesures.Add(Mesure);
+            }
             #endregion
             public void AddMesure(MesureCalibration mesure)
+            {
                 mesure.Calibration = this;
                 var index = Mesures.FindIndex(m => m.Type == mesure.Type);
                 if (index != -1)
+                {

     using SQLite;
     using System.ComponentModel.DataAnnotations.Schema;
     namespace GES_PAC.Model
+    {
         public class Comportement
+        {
             public long Id { get; set; }
             #region Propri?t?s
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public int SerieAnimalId { get; set; }
             [ForeignKey("SerieAnimalId")]
             public SerieAnimal SerieAnimal { get; set; }
             public DateTime Time { get; set; }
             public int TypeComportementId { get; set; }
             [ForeignKey("TypeComportementId")]
             public TypeComportement Type { get; set; }
             public string? Commentaire { get; set; }
             #endregion
             #region Constructeurs
             public Comportement() { }
             public Comportement(DateTime Time, TypeComportement Type, string Commentaire)
+            {
                 this.Time = Time;
                 this.Type = Type;
                 this.Commentaire = Commentaire;
+            }
             #endregion
+        }
+    }

     using SQLite;
     namespace GES_PAC.Model
+    {
         internal interface IMesureBase
+        {
             #region Propriétés
             public int Id { get; set; }
             public DateTime Time { get; set; }
             public double Conc_O2 { get; set; }
             public double Conc_CO2 { get; set; }
             public double Conc_CH4 { get; set; }
             #endregion
+        }
+    }

     using SQLite;
     using System.ComponentModel.DataAnnotations.Schema;
     namespace GES_PAC.Model
+    {
         public class Journee
+        {
             #region Propriétés
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public int PersonneId { get; set; }
             [ForeignKey("PersonneId")]
             public Personne Responsable { get; set; }
             public int LieuId { get; set; }
             [ForeignKey("LieuId")]
             public Lieu Lieu { get; set; }
             public long Id { get; set; }
             public DateTime Date { get; set; }
             public string Regime { get; set; }
             public List<Serie> Series { get; set; }
             public List<Calibration> Calibrations { get; set; }
             public List<Serie> Series { get; set; } = [];
             public List<Calibration> Calibrations { get; set; } = [];
             #endregion
             #region Constructeurs
             public Journee(){}
             public Journee(DateTime Date, Personne Responsable, Lieu Lieu, string Regime)
+            {
                 this.Responsable = Responsable;
-...
             #endregion
             #region Méthodes
             public bool AddCalibration(MesureCalibration mesureCalibration, PhaseCalibration phaseCalibration)
+            {
                 var existing = Calibrations.FirstOrDefault(c => c.Phase == phaseCalibration);
                 if (existing == null)
+                {
                     Calibrations.Add(new Calibration(phaseCalibration, mesureCalibration));
                     return false;
+                }
                 existing.AddMesure(mesureCalibration);
                 return existing.IsComplete();
+            }
             public void AddSet(Serie set)
+            {
                 set.Journee = this;
                 Series.Add(set);
+            }
             public PhaseCalibration GetCurrentPhase()
             public List<TypeCalibration> GetMissingCalibrationByPhase(PhaseCalibration phase)
+            {
                 if (Series.Count == 0)
+                {
                     return PhaseCalibration.DEBUT;
+                }
                 return PhaseCalibration.FIN;
+            }
                 if (phase == null)
                     return TypeCalibration.All;
             public Calibration GetCurrentCalibration()
+            {
                 return Calibrations.FirstOrDefault(c => c.Phase == GetCurrentPhase());
+            }
                 var calibPhase = Calibrations.FirstOrDefault(c => c.Phase == phase);
             public List<TypeCalibration> GetCurrentMissingCalibration()
+            {
                 if (Calibrations.Count == 0 || Calibrations.Last().IsComplete())
+                {
                 if (calibPhase == null || calibPhase.IsComplete())
                     return TypeCalibration.All;
+                }
                 return TypeCalibration.All.Except(Calibrations.Last().GetTypesDone()).ToList();
                 return TypeCalibration.All.Except(calibPhase.GetTypesDone()).ToList();
+            }
             public Serie GetCurrentSet()
             public Serie? GetCurrentSet()
+            {
                 return Series.LastOrDefault();
                 return Series?.LastOrDefault();
+            }
             public bool HasAnySet()
+            {
-...
+            }
             internal Calibration GetDebutCalibration()
+            {
                 return Calibrations.FirstOrDefault(c => c.Phase == PhaseCalibration.DEBUT);
                 return Calibrations.FirstOrDefault(c => c.Phase?.Value == PhaseCalibration.DEBUT.Value);
+            }
             internal bool IsCalibrationComplete(PhaseCalibration pc)
+            {
                 return Calibrations.FirstOrDefault(c => c.Phase == pc)?.IsComplete() ?? false;
                 return Calibrations?.FirstOrDefault(c => c.Phase == pc)?.IsComplete() ?? false;
+            }
             internal bool IsComplete()
+            {
                 return Calibrations.FirstOrDefault(c => c.Phase == PhaseCalibration.FIN)?.IsComplete() ?? false;
                 return Calibrations?.FirstOrDefault(c => c.Phase == PhaseCalibration.FIN)?.IsComplete() ?? false;
+            }
             internal void AddCalibration(Calibration calibration)
+            {
                 calibration.Journee = this;
                 Calibrations.Add(calibration);
+            }
             #endregion
+        }

GES_PAC/Model/Lieu.cs
1	1
	2	using SQLite;
	3
2	4	namespace GES_PAC.Model
3	5	{
4	6	public class Lieu
5	7	{
6		public long Id { get; set; }
	8	#region Propri?t?s
	9	[PrimaryKey, AutoIncrement]
	10	public int Id { get; set; }
7	11	public string Nom { get; set; }
8	12	public string Client { get; set; }
9	13	public string Espece { get; set; }
	14	#endregion
10	15
	16	#region Constructeurs
	17	public Lieu() { }
11	18	public Lieu(string nom, string client, string espece)
12	19	{
13	20	Nom = nom;
14	21	Client = client;
15	22	Espece = espece;
16	23	}
	24	#endregion
17	25
18	26	public override string ToString()
19	27	{

     using SQLite;
     using System.ComponentModel.DataAnnotations.Schema;
     namespace GES_PAC.Model
+    {
         public class Mesure
         public class Mesure : IMesureBase
+        {
             public long Id { get; set; }
             #region Propri?t?s
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public DateTime Time { get; set; }
             public double Conc_O2 { get; set; }
             public double Conc_CO2 { get; set; }
             public double Conc_CH4 { get; set; }
             public int SerieAnimalId { get; set; }
             [ForeignKey("SerieAnimalId")]
             public SerieAnimal SerieAnimal { get; set; }
             #endregion
             #region Constructeurs
             public Mesure() { }
             public Mesure(DateTime Time, double Conc_O2, double Conc_CO2, double Conc_CH4)
+            {
                 this.Time = Time;
-...
                 this.Conc_CO2 = Conc_CO2;
                 this.Conc_CH4 = Conc_CH4;
+            }
             #endregion
+        }
+    }

     using SQLite;
     using System.ComponentModel.DataAnnotations.Schema;
     namespace GES_PAC.Model
+    {
         public class MesureCalibration : Mesure
         public class MesureCalibration : IMesureBase
+        {
             #region Propri?t?s
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public DateTime Time { get; set; }
             public double Conc_O2 { get; set; }
             public double Conc_CO2 { get; set; }
             public double Conc_CH4 { get; set; }
             public int TypeCalibrationId { get; set; }
             [ForeignKey("TypeCalibrationId")]
             public TypeCalibration Type { get; set; }
             public string RefBouteille { get; set; }
             public string? RefBouteille { get; set; }
             public int CalibrationId { get; set; }
             [ForeignKey("CalibrationId")]
             public Calibration Calibration { get; set; }
             public MesureCalibration(DateTime Time, double Conc_O2, double Conc_CO2, double Conc_CH4, TypeCalibration Type, string RefBouteille) : base(Time, Conc_O2, Conc_CO2, Conc_CH4)
             #endregion
             #region Constructeurs
             public MesureCalibration() { }
             public MesureCalibration(DateTime Time, double Conc_O2, double Conc_CO2, double Conc_CH4, TypeCalibration Type, string RefBouteille)
+            {
                 this.Time = Time;
                 this.Conc_O2 = Conc_O2;
                 this.Conc_CO2 = Conc_CO2;
                 this.Conc_CH4 = Conc_CH4;
                 this.Type = Type;
                 if (Type.Value != 0)
+                {
                     this.RefBouteille = RefBouteille;
+                }
+            }
             #endregion
+        }
+    }

     using SQLite;
     namespace GES_PAC.Model
+    {
         public class Personne
+        {
             public long Id { get; set; }
             #region Propri?t?s
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public string? Nom { get; set; }
             public string? Prenom { get; set; }
             public string? Email { get; set; }
             #endregion
             #region Constructeurs
             public Personne() { }
             public Personne(string Nom, string Prenom, string Email)
+            {
-...
                 this.Prenom = Prenom;
                 this.Email = Email;
+            }
             #endregion
             public override string ToString()
+            {
                 return $"{Nom} {Prenom}";

     using SQLite;
     namespace GES_PAC.Model
+    {
         public class PhaseCalibration
+        {
             public string Name { get; }
             public int Value { get; }
             #region Propri?t?s
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public string Name { get; set; }
             public int Value { get; set; }
             #endregion
             #region Constructeurs
             public PhaseCalibration() { }
             private PhaseCalibration(string name, int value)
+            {
                 Name = name;
                 Value = value;
+            }
             #endregion
             public static readonly PhaseCalibration DEBUT = new("d?but", 1);
             public static readonly PhaseCalibration FIN = new("fin", 2);

     using System.Collections.ObjectModel;
     using SQLite;
     using System.ComponentModel.DataAnnotations.Schema;
     namespace GES_PAC.Model
+    {
         public class Serie
+        {
             #region Propriétés
             public long Id { get; set; }
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public int JourneeId { get; set; }
             [ForeignKey("JourneeId")]
             public Journee Journee { get; set; }
             public DateTime Time { get; set; }
             public DateTime MiseAJeun { get; set; }
             public double Temperature { get; set; }
-...
             #endregion
             #region Constructeurs
             public Serie() { }
             public Serie(DateTime Time, DateTime MiseAJeun, double Temperature, double Humidite, double Pression)
+            {
                 this.Time = Time;
-...
             #region Méthodes
             public void AddSerieAnimal(SerieAnimal serieAnimal)
+            {
                 serieAnimal.Serie = this;
                 var existing = SeriesAnimales.FirstOrDefault(s => s.NumeroBoite == serieAnimal.NumeroBoite);
                 if (existing != null)
                     SeriesAnimales.Remove(existing);

     using Microsoft.Maui.Layouts;
     using SQLite;
     using System.ComponentModel.DataAnnotations.Schema;
     namespace GES_PAC.Model
+    {
         public class SerieAnimal
+        {
             public long Id { get; set; }
             #region Propriétés
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public int NumeroBoite { get; set; }
             public double Poids { get; set; }
             public DateTime DatePesee { get; set; }
             public string RFID { get; set; }
             public List<Mesure> Mesures { get; set; }
             public List<Comportement> Comportements { get; set; }
             public int SerieId { get; set; }
             [ForeignKey("SerieId")]
             public Serie Serie { get; set; }
             public bool IsOut { get; set; } = false;
             #endregion
             #region Constructeurs
             public SerieAnimal() { }
             public SerieAnimal(int numeroBoite, double poids, DateTime datePesee, string rFID)
+            {
                 NumeroBoite = numeroBoite;
-...
                 Mesures = [];
                 Comportements = [];
+            }
             #endregion
             public int GetMeasureCount()
+            {
-...
             internal void AddMeasure(Mesure newMeasure)
+            {
                 newMeasure.SerieAnimal = this;
                 Mesures.Add(newMeasure);
+            }
-...
             public void AddBehaviour(Comportement newBehaviour)
+            {
                 newBehaviour.SerieAnimal = this;
                 Comportements.Add(newBehaviour);
+            }

     using SQLite;
     namespace GES_PAC.Model
+    {
         public class TypeCalibration
+        {
             public string Name { get; }
             public int Value { get; }
             #region Propri?t?s
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public string Name { get; set; }
             public int Value { get; set; }
             #endregion
             private TypeCalibration(string name, int value) // a passer en public quand integration webservice
             #region Constructeurs
             public TypeCalibration() { }
             private TypeCalibration(string name, int value)
+            {
                 Name = name;
                 Value = value;
+            }
             #endregion
             public static readonly TypeCalibration Air = new("AIR", 0);
             public static readonly TypeCalibration Methane = new("METHANE", 1);
             public static readonly TypeCalibration Melange = new("MELANGE", 2);
             public static readonly TypeCalibration AIR = new("Air", 0);
             public static readonly TypeCalibration METHANE = new("M?thane", 1);
             public static readonly TypeCalibration MELANGE = new("M?lange", 2);
             public static readonly List<TypeCalibration> All = new() { Air, Methane, Melange };
             public static readonly List<TypeCalibration> All = new() { AIR, METHANE, MELANGE };
             public override string ToString() => Name;
+        }

     using SQLite;
     namespace GES_PAC.Model
+    {
         public class TypeComportement
+        {
             public string Name { get; }
             public int Value { get; }
             #region Propri?t?s
             [PrimaryKey, AutoIncrement]
             public int Id { get; set; }
             public string Name { get; set; }
             public int Value { get; set; }
             #endregion
             #region Constructeurs
             public TypeComportement() { }
             private TypeComportement(string name, int value)
+            {
                 Name = name;
                 Value = value;
+            }
             #endregion
             public static readonly TypeComportement IMMOBILITE = new("Immobilit?", 1);
             public static readonly TypeComportement DEPLACEMENT_AVANT_ARRIERE = new("D?placement avant/arri?re", 2);

             ContentValues values = new ContentValues();
             values.Put(MediaStore.IMediaColumns.DisplayName, fileName);
             values.Put(MediaStore.IMediaColumns.MimeType, "text/json");
             values.Put(MediaStore.IMediaColumns.MimeType, "application/json");
             values.Put(MediaStore.IMediaColumns.RelativePath, $"{Android.OS.Environment.DirectoryDownloads}/GES_PAC");

     using Microsoft.EntityFrameworkCore;
     using GES_PAC.Model;
     public class AppDbContext : DbContext
+    {
         public AppDbContext() { }
         public DbSet<Calibration> Calibration { get; set; }
         public DbSet<Comportement> Comportement { get; set; }
         public DbSet<Journee> Journee { get; set; }
         public DbSet<Lieu> Lieu { get; set; }
         public DbSet<Mesure> Mesure { get; set; }
         public DbSet<MesureCalibration> MesureCalibration { get; set; }
         public DbSet<Personne> Personne { get; set; }
         public DbSet<PhaseCalibration> PhaseCalibration { get; set; }
         public DbSet<Serie> Serie { get; set; }
         public DbSet<SerieAnimal> SerieAnimal { get; set; }
         public DbSet<TypeCalibration> TypeCalibration { get; set; }
         public DbSet<TypeComportement> TypeComportement { get; set; }
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
             string dbPath = Path.Combine(FileSystem.AppDataDirectory, "GES_PAC.db3");
             optionsBuilder.UseSqlite($"Filename={dbPath}");
+        }
         protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+        }
+    }

                 var currentSet = JourneeViewModel.Instance.GetCurrentDay().GetCurrentSet();
                 currentSet.AddBehaviour(newBehaviour, ChamberId, IsAnimalOut);
                 App.Db.Comportement.Add(newBehaviour);
                 await App.Db.SaveChangesAsync();
                 await Shell.Current.Navigation.PopToRootAsync();
                 IsBusy = false;
+            }

     using GES_PAC.Model;
     using GES_PAC.View;
     using Microsoft.EntityFrameworkCore;
     using System.Collections.ObjectModel;
     using System.Windows.Input;
-...
             #region Attributs
             public string _phaseName;
             private ObservableCollection<TypeCalibration> _typeCalibrations;
             private TypeCalibration _selectedType;
             private double? _conc_o2;
             private double? _conc_co2;
-...
                 get => _phaseName;
                 set
+                {
                     if (_phaseName == value) return;
                     _phaseName = value;
                     Phase = PhaseCalibration.All.FirstOrDefault(p => p.Name == value) ?? PhaseCalibration.DEBUT;
                     OnPropertyChanged();
                     OnPhaseChanged();
+                }
+            }
             public ObservableCollection<TypeCalibration> TypeCalibrations { get; }
             public ObservableCollection<TypeCalibration> TypeCalibrations
+            {
                 get => _typeCalibrations;
                 set
+                {
                     _typeCalibrations = value;
                     OnPropertyChanged();
+                }
+            }
             public TypeCalibration SelectedType
+            {
                 get => _selectedType;
                 set
+                {
                     _selectedType = value;
                     IsRefBouteilleVisible = _selectedType != TypeCalibration.Air;
                     IsRefBouteilleVisible = _selectedType != TypeCalibration.AIR;
                     OnPropertyChanged();
                     OnTypeChanged();
                     ValidateForm();
-...
             public CreateCalibrationViewModel()
+            {
                 CreateCalibrationCommand = new Command(async () => await CreateCalibration());
+            }
             #endregion
             #region Méthodes
             public void OnPhaseChanged()
+            {
                 var journeeActuelle = JourneeViewModel.Instance.GetCurrentDay();
                 var typesManquants = journeeActuelle.GetCurrentMissingCalibration();
                 var phaseCalibration = journeeActuelle.GetCurrentPhase();
                 var typesManquants = journeeActuelle.GetMissingCalibrationByPhase(Phase);
                 TypeCalibrations = new ObservableCollection<TypeCalibration>(typesManquants);
                 SelectedType = TypeCalibrations[0];
                 if (journeeActuelle.GetCurrentPhase() == PhaseCalibration.FIN)
+                {
                 if (Phase == PhaseCalibration.FIN)
+                {
                     LastCalibration = journeeActuelle.GetDebutCalibration();
                     HasLastMeasure = true;
                     OnTypeChanged();
+                }
+            }
             #endregion
             #region Méthodes
             private async Task CreateCalibration()
+            {
                 if (IsBusy) return;
                 IsBusy = true;
                 var journee = JourneeViewModel.Instance.GetCurrentDay();
                 var date = DateTime.Now;
                 var newCalib = new MesureCalibration(date, ConcO2 ?? 0, ConcCO2 ?? 0, ConcCH4 ?? 0, SelectedType, RefBouteille);
                 var isComplete = JourneeViewModel.Instance.GetCurrentDay().AddCalibration(newCalib, Phase);
                 var calibration = journee.Calibrations.FirstOrDefault(c => c.Phase == Phase);
                 if (calibration == null)
+                {
                     calibration = new Calibration(Phase, newCalib);
                     journee.AddCalibration(calibration);
                     App.Db.Calibration.Add(calibration);
+                }
                 else
+                {
                     calibration.AddMesure(newCalib);
+                }
                 App.Db.MesureCalibration.Add(newCalib);
                 await App.Db.SaveChangesAsync();
                 var isComplete = calibration.IsComplete();
                 var targetView = $"{nameof(CreateCalibrationView)}?phase={PhaseName}";
                 if (isComplete) {
                     targetView = Phase == PhaseCalibration.DEBUT ? nameof(SetListView) : nameof(MainView);

                 IsBusy = true;
                 var date = DateTime.Now;
                 var newDay = new Journee(date, SelectedPerson, SelectedPlace, Regime);
                 App.Db.Journee.Add(newDay);
                 await App.Db.SaveChangesAsync();
                 JourneeViewModel.Instance.Journees.Add(newDay);
                 await Shell.Current.GoToAsync($"{nameof(CreateCalibrationView)}?phase={PhaseCalibration.DEBUT.Name}");
                 IsBusy = false;

                 var currentSet = JourneeViewModel.Instance.GetCurrentDay().GetCurrentSet();
                 currentSet.AddMeasure(newMeasure, ChamberId, IsAnimalOut);
                 App.Db.Mesure.Add(newMeasure);
                 await App.Db.SaveChangesAsync();
                 await Shell.Current.Navigation.PopToRootAsync();
                 IsBusy = false;
+            }

GES_PAC/ViewModel/CreatePersonViewModel.cs
76	76	private async Task CreatePerson()
77	77	{
78	78	var newTechnician = new Personne(Nom, Prenom, Email);
	79	App.Db.Personne.Add(newTechnician);
	80	await App.Db.SaveChangesAsync();
	81
79	82	PersonViewModel.Instance.Persons.Add(newTechnician);
80	83	await Shell.Current.GoToAsync("//Main");
81	84	}

GES_PAC/ViewModel/CreatePlaceViewModel.cs
88	88	private async Task CreatePlace()
89	89	{
90	90	var newPlace = new Lieu(Nom, Client, Espece);
	91	App.Db.Lieu.Add(newPlace);
	92	await App.Db.SaveChangesAsync();
	93
91	94	PlaceViewModel.Instance.Places.Add(newPlace);
92	95	await Shell.Current.GoToAsync("//Main");
93	96	}

     using GES_PAC.Model;
     using GES_PAC.View;
     using System.Windows.Input;
     namespace GES_PAC.ViewModel
-...
                 var newSet = new Serie(date, DateTimeMAJ, Temperature ?? 0, Humidite ?? 0, Pression ?? 0);
                 journeeActuelle.AddSet(newSet);
                 App.Db.Serie.Add(newSet);
                 await App.Db.SaveChangesAsync();
                 await Shell.Current.Navigation.PopToRootAsync();
                 IsBusy = false;
+            }

                 var newAnimalSet = new SerieAnimal(ChamberId, Poids ?? 0, date, NumRFID);
                 journeeActuelle.GetCurrentSet().AddSerieAnimal(newAnimalSet);
                 App.Db.SerieAnimal.Add(newAnimalSet);
                 await App.Db.SaveChangesAsync();
                 await Shell.Current.GoToAsync($"{nameof(CreateMeasureView)}?chamberId={ChamberId}");
                 IsBusy = false;
+            }

     using GES_PAC.Helpers;
     using System.Text.Json;
     using System.Collections.ObjectModel;
     using System.Text.Json.Serialization;
     namespace GES_PAC.ViewModel
-...
                 IsBusy = true;
                 var lastDay = DayList.Last();
                 string fileName = lastDay.Date.ToString();
                 string json = JsonSerializer.Serialize(lastDay);
                 string json = JsonSerializer.Serialize(lastDay, new JsonSerializerOptions
+                {
                     ReferenceHandler = ReferenceHandler.Preserve,
                     WriteIndented = true
                 });
                 AndroidFileHelper.SaveJsonToDownloads(fileName, json);
                 IsBusy = false;
     #endif

     using GES_PAC.Model;
     using Microsoft.EntityFrameworkCore;
     using System.Collections.ObjectModel;
     namespace GES_PAC.ViewModel
-...
             #endregion
             #region Constructeurs
             private JourneeViewModel() { }
             private JourneeViewModel() {
                 _ = InitAsync();
+            }
             #endregion
             #region Méthodes
             public Journee GetCurrentDay()
             public async Task InitAsync()
+            {
                 DateTime today = DateTime.Today;
                 return Journees.LastOrDefault(j => j.Date.Date == today);
                 var journees = await App.Db.Journee
                     .Include(j => j.Calibrations)
                         .ThenInclude(c => c.Mesures)
                             .ThenInclude(m => m.Type)
                     .Include(j => j.Calibrations)
                         .ThenInclude(c => c.Phase)
                     .Include(j => j.Series)
                         .ThenInclude(s => s.SeriesAnimales)
                             .ThenInclude(sa => sa.Mesures)
                     .Include(j => j.Series)
                         .ThenInclude(s => s.SeriesAnimales)
                             .ThenInclude(sa => sa.Comportements)
                     .ToListAsync();
                 foreach (var j in journees)
+                {
                     foreach (var c in j.Calibrations)
+                    {
                         c.Phase = PhaseCalibration.All.FirstOrDefault(p => p.Value == c.Phase?.Value);
                         foreach (var m in c.Mesures)
+                        {
                             m.Type = TypeCalibration.All.FirstOrDefault(t => t.Value == m.Type?.Value);
+                        }
+                    }
                     Journees.Add(j);
+                }
+            }
             public PhaseCalibration GetCurrentPhase()
             public Journee? GetCurrentDay()
+            {
                 return GetCurrentDay().GetCurrentPhase();
                 DateTime today = DateTime.Today;
                 var lastDay = Journees.LastOrDefault(j => j.Date.Date == today);
                 if (lastDay == null || lastDay.IsComplete())
                     return null;
                 return lastDay;
+            }
             public Serie? GetCurrentSet()
+            {

             #region Constructeur
             public MainViewModel()
+            {
                 //ONLY FOR TESTS
                 var date = DateTime.Now.AddHours(-2);
                 var newDay = new Journee(date, PersonViewModel.Instance.Persons[0], PlaceViewModel.Instance.Places[0], "");
                 newDay.AddSet(new Serie(date, date, 25, 25, 25));
                 newDay.AddCalibration(new MesureCalibration(date, 50, 40, 500, TypeCalibration.Air, ""), PhaseCalibration.DEBUT);
                 newDay.AddCalibration(new MesureCalibration(date, 0, 0, 1000000, TypeCalibration.Methane, "dazdazd"), PhaseCalibration.DEBUT);
                 newDay.AddCalibration(new MesureCalibration(date, 30, 30, 3000, TypeCalibration.Melange, "deqsfsdf"), PhaseCalibration.DEBUT);
                 newDay.GetCurrentSet().AddSerieAnimal(new SerieAnimal(1, 500, date, ""));
                 newDay.GetCurrentSet().AddMeasure(new Mesure(date, 50, 50, 50), 1, false);
                 JourneeViewModel.Instance.Journees.Add(newDay);
                 //ONLY FOR TESTS
                 GoToCreateDayCommand = new Command(async () => await GoToCreateDayPage());
                 ResumeDayCommand = new Command(async () => await ResumeDay());

     using GES_PAC.Model;
     using Microsoft.EntityFrameworkCore;
     using System.Collections.ObjectModel;
     namespace GES_PAC.ViewModel
-...
             #region Constructeur
             private PersonViewModel() {
                 Persons.Add(new Personne("Bond", "James", "jamesbond@inrae.fr")); // Ajout d'une personne par défaut pour les tests
                 _ = InitAsync();
+            }
             #endregion
             #region Méthodes
             public async Task InitAsync()
+            {
                 var personnes = await App.Db.Personne.ToListAsync();
                 foreach (var p in personnes)
                     Persons.Add(p);
+            }
             #endregion
+        }

     using GES_PAC.Model;
     using Microsoft.EntityFrameworkCore;
     using System.Collections.ObjectModel;
     namespace GES_PAC.ViewModel
+    {
         public class PlaceViewModel
-...
             #region Constructeur
             private PlaceViewModel() {
                 Places.Add(new Lieu("Elevage Langlade", "INRAE", "Mouton")); // Ajout d'un lieu par défaut pour les tests
                 _ = InitAsync();
+            }
             #endregion
             #region Méthodes
             public async Task InitAsync()
+            {
                 var lieux = await App.Db.Lieu.ToListAsync();
                 foreach (var l in lieux)
                     Places.Add(l);
+            }
             #endregion
+        }

GES_PAC

Révision 6f451cc1