context

src/CalculateurMoyanne/BSN/IDataManager.cs

@@ -16,5 +16,6 @@ namespace Bussness
         Task<Data> GetDataWithName(string name);
         Task<List<Data>> GetAll();
         Task<bool> AddUEBloc(UE data, int blocId);
+
     }
 }

src/CalculateurMoyanne/BSN/IMaquetteDbManager.cs

@@ -0,0 +1,11 @@
+using System;
+using ClassCalculateurMoyenne;
+
+namespace Bussness
+{
+	public interface IMaquetteDbManager : IDataManager<MaquetteModel>
+	{
+        Task<bool> AddBlocmaquette(MaquetteModel mqt, BlocModel blocModel);
+    }
+}
+

src/CalculateurMoyanne/BSN/Manager.cs

@@ -20,10 +20,12 @@ namespace Bussness
         public ReadOnlyCollection<Matiere> matiere { get; private set; }
         private readonly List<Matiere> matieres = new();
 
+        public MaquetteModel SelectedMaquetteModel { get; set; }
+
 
 
         public IDataManager<MaquetteModel> MaquetteDbDataManager => maquetteDbDataManager;
-        private readonly IDataManager<MaquetteModel> maquetteDbDataManager;
+        private readonly IMaquetteDbManager maquetteDbDataManager;
         public IDataManager<BlocModel> BlocDbDataManager => blocDbDataManager;
         private readonly IDataManager<BlocModel> blocDbDataManager;
         public IDataManager<UE> UeDbDataManager => ueDbDataManager;
@@ -36,7 +38,7 @@ namespace Bussness
 
      #region Constructeurs
 
-        public Manager(IDataManager<MaquetteModel> maquettemanager)
+        public Manager(IMaquetteDbManager maquettemanager)
         {
            this.maquetteDbDataManager = maquettemanager;
             maquette = new ReadOnlyCollection<MaquetteModel>(maquettes);
@@ -58,7 +60,7 @@ namespace Bussness
             matiere = new ReadOnlyCollection<Matiere>(matieres);
         }
 
-        public Manager(IDataManager<Matiere> matiereManager,IDataManager<UE> UeManager, IDataManager<BlocModel> blocmanager, IDataManager<MaquetteModel> maquettemanager)
+        public Manager(IDataManager<Matiere> matiereManager,IDataManager<UE> UeManager, IDataManager<BlocModel> blocmanager, IMaquetteDbManager maquettemanager)
         {
         this.matiereDbDataManager = matiereManager;
         matiere = new ReadOnlyCollection<Matiere>(matieres);
@@ -125,6 +127,17 @@ namespace Bussness
 
             return blocDbDataManager.Add(bloc);
         }
+        public async Task<bool> AddBlocmaquette(MaquetteModel mqt, BlocModel blocModel)
+        {
+            var response = maquetteDbDataManager == null;
+            if (response)
+            {
+                return false;
+            }
+
+            return await maquetteDbDataManager.AddBlocmaquette(mqt, blocModel);
+        }
+
         //public Task<bool> Adddansbloc(BlocModel bloc)
         //{
         //    if (blocDbDataManager == null)

src/CalculateurMoyanne/CalculateurApp/App.xaml.cs

@@ -1,6 +1,10 @@
 using CalculateurApp.View;
 using CalculateurApp.ViewModel;
 using ClassCalculateurMoyenne;
+using Bussness;
+
+//using Java.Util.Logging;
+using CalculateurMapping;
 
 namespace CalculateurApp
 {
@@ -13,10 +17,20 @@ namespace CalculateurApp
             // MainPage = new NavigationPage(new HomePage());
             //MainPage = new AppShell(BlocViewModel c);
             //    MainPage = new EXE ();
+
+           
             MainPage = new AppShell();
-           // MainPage = new Maquette();
+
+
+            //  MainPage = new BlockView();
 
 
         }
+        public Manager manager { get; set; } = new Manager( null, null, new BlocDbDataManager<CalculDbMaui>(), new MaquetteDbDataManager<CalculDbMaui>())
+        {
+
+        };
+
+
     }
 }

src/CalculateurMoyanne/CalculateurApp/View/BlockView.xaml.cs

@@ -8,11 +8,16 @@ namespace CalculateurApp.View;
 
 public partial class BlockView : ContentPage
 {
-    
-	public BlockView()
+    public Manager Manager => (Application.Current as App).manager;
+
+
+    public BlockView()
 	{
 		InitializeComponent();
-        BindingContext = new MaquetteViewModel ();
+        var mvm = new MaquetteViewModel();
+        mvm.manager = Manager;
+        mvm.init1();
+        BindingContext = mvm;
     }
     private async void Aer(object sender, EventArgs e)
     {

src/CalculateurMoyanne/CalculateurApp/View/Maquette.xaml

@@ -34,9 +34,8 @@
             Grid.Column="2"
             HorizontalOptions="End"
             VerticalOptions="End"
-            BackgroundColor="AliceBlue"
             WidthRequest="85"></Button>
-        <Button
+        <!--<Button
             Command=" {Binding GetAllMaquetteCommand}"
             Text="afficher"
              Grid.Row="2"
@@ -46,7 +45,7 @@
             WidthRequest="100">
       
 
-        </Button>
+        </Button>-->
         <CollectionView Grid.Row="3" Grid.ColumnSpan="1" ItemsSource="{Binding Items}" SelectionMode="Multiple" BackgroundColor="White">
             <CollectionView.ItemTemplate>
                 <DataTemplate x:DataType="{x:Type  model:MaquetteModel }">
@@ -70,7 +69,7 @@
                             <Frame Grid.Row="1">
                                 <Frame.GestureRecognizers >
                                     <TapGestureRecognizer  
-                                           Command="{Binding Source={RelativeSource AncestorType={x:Type  viewmodel:MaquetteViewModel}}, Path=GoBackCommand}"
+                                           Command="{Binding Source={RelativeSource AncestorType={x:Type  viewmodel:PageAjoutMaquette}}, Path=TapCommand}"
                                            CommandParameter="{Binding .}" />
                                 </Frame.GestureRecognizers>
                                 <Label Text="{Binding NomMaquette}" 

src/CalculateurMoyanne/CalculateurApp/View/Maquette.xaml.cs

@@ -1,11 +1,17 @@
 using CalculateurApp.ViewModel;
+using Bussness;
+using ClassCalculateurMoyenne;
 
 namespace CalculateurApp.View;
 
 public partial class AjtMaquette : ContentPage
 {
+	public Manager Manager => (Application.Current as App).manager;
+
 	public AjtMaquette(PageAjoutMaquette vm)
 	{
+		vm.manager = Manager;
+		vm.Init();
 		InitializeComponent();
 		BindingContext = vm;
 		Routing.RegisterRoute(nameof(BlockView), typeof(BlockView));

src/CalculateurMoyanne/CalculateurApp/ViewModel/MaquetteViewModel.cs

@@ -1,6 +1,7 @@
 using Bussness;
 using CalculateurApp.View;
 using CalculateurEF.Context;
+using CalculateurEF;
 using CalculateurMapping;
 using ClassCalculateurMoyenne;
 using CommunityToolkit.Mvvm.ComponentModel;
@@ -8,6 +9,7 @@ using CommunityToolkit.Mvvm.Input;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.Linq;
 using System.Reflection.Metadata;
 using System.Text;
@@ -20,42 +22,84 @@ namespace CalculateurApp.ViewModel
        
         public BlocModel blocModel { get; set; }
        // public ReadOnlyObservableCollection<BlocModel>lst { get; set; }
-        public Manager manager;
+        public Manager manager { get; set; }
+
 
         public MaquetteViewModel()
+        {
+            //Items = new ObservableCollection<BlocModel>();
+
+            //try
+            //{
+            //    foreach (var BB in manager.GetAllBloc().Result)
+            //        Items.Add(BB);
+            //}
+            //catch (Exception ex)
+            //{
+            //    Debug.WriteLine(ex);
+            //}
+           
+
+            //blocModel = new BlocModel();
+        }
+        public void init1()
         {
             Items = new ObservableCollection<BlocModel>();
-            //foreach (var BB in manager.GetAllBloc().Result)
-            //    Items.Add(BB);
+
+            try
+            {
+                foreach (var BB in manager.GetAllBloc().Result)
+                    Items.Add(BB);
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine(ex);
+            }
+
+
             blocModel = new BlocModel();
         }
         [ObservableProperty]
         ObservableCollection<BlocModel> items;
         [ObservableProperty]
         ObservableCollection<BlocModel> lstblc=new ObservableCollection<BlocModel>();
-
         [ObservableProperty]
         string nom;
-       
-        [RelayCommand]
-        void Add()
+
+    [RelayCommand]
+        async void Add()
         {
-            Manager blocDbDataManager = new Manager(new BlocDbDataManager<CalculDbMaui>());
+           // Manager blocDbDataManager = new Manager(new BlocDbDataManager<CalculDbMaui>());
+         
             if (string.IsNullOrEmpty(blocModel.Nom))
                 return;
-            BlocModel u = new BlocModel(blocModel.Nom);        
-            Items.Add(u);
-            blocDbDataManager.AddBloc(blocModel);
-            blocModel.Nom = string.Empty; 
+            //BlocModel u = blocModel;
+            //MaquetteModel u = new MaquetteModel();
+            Items.Add(blocModel);
+          await  manager.AddBlocmaquette(manager.SelectedMaquetteModel, blocModel);
+
         }
          [RelayCommand]
-        void Delete(BlocModel bl)
+        async void Delete(BlocModel bl)
         
         {
             if (Items.Contains(bl))
             {
                 Items.Remove(bl);
+                await manager.DeleteBloc(bl);
+                var o = await manager.GetAllBloc();
             }
+
+           
+            //if (Items.Contains(model))
+            //{
+            //    Items.Remove(model);
+            //    await manager.Deletemqt(model);
+
+            //    var v = await manager.GetAllMaquette();
+            //    Console.WriteLine(v);
+
+            //}
         }
         
         [RelayCommand]
@@ -73,7 +117,7 @@ namespace CalculateurApp.ViewModel
         [RelayCommand]
         async Task Tap(String s)
         {
-            await Shell.Current.GoToAsync($"{nameof(BlocModel)}?Nom={s}");
+            await Shell.Current.GoToAsync($"{nameof(UE)}?Nom={s}");
 
         }
         [RelayCommand]

src/CalculateurMoyanne/CalculateurApp/ViewModel/PageAjoutMaquette.cs

@@ -13,18 +13,23 @@ namespace CalculateurApp.ViewModel
     public partial class PageAjoutMaquette : ObservableObject
     {
         public MaquetteModel maquette { get; set; }
-        public Manager manager;
+        public Manager manager { get; set; }
 
 
         public PageAjoutMaquette()
         {
-            manager = new Manager(new MaquetteDbDataManager<CalculDbMaui>());
+            //manager = new Manager(new MaquetteDbDataManager<CalculDbMaui>());
 
+            
+
+        }
+
+        public void Init()
+        {
             Items = new ObservableCollection<MaquetteModel>();
-            foreach(var mm in manager.GetAllMaquette().Result)
-           Items.Add( mm);
+            foreach (var mm in manager.GetAllMaquette().Result)
+                Items.Add(mm);
             maquette = new MaquetteModel();
-
         }
 
         [ObservableProperty]
@@ -38,13 +43,13 @@ namespace CalculateurApp.ViewModel
         [RelayCommand]
         async void Add()
         {
-            Manager maquetteDbDataManager = new Manager(new MaquetteDbDataManager<CalculDbMaui>());
+            //Manager maquetteDbDataManager = new Manager(new MaquetteDbDataManager<CalculDbMaui>());
 
             if (string.IsNullOrEmpty(NomMaquette))
                 return;
             MaquetteModel u = maquette;
             Items.Add(u);
-            await maquetteDbDataManager.AddMaquette(maquette);
+            await manager.AddMaquette(maquette);
             //maquette.NomMaquette = string.Empty;
            
         }
@@ -69,18 +74,19 @@ namespace CalculateurApp.ViewModel
         [RelayCommand]
         async void GetAllMaquette()
         {
-            Manager maquetteDbDataManager = new Manager(new MaquetteDbDataManager<CalculDbMaui>());
+            //Manager maquetteDbDataManager = new Manager(new MaquetteDbDataManager<CalculDbMaui>());
 
-            await maquetteDbDataManager.GetAllMaquette();
+            await manager.GetAllMaquette();
         }
         [RelayCommand]
-        async Task GoBack(string maquetteName)
+        async Task Tap(MaquetteModel maquetteName)
         {
-            var maquette = manager.GetMaquetteByName(maquetteName);
+            manager.SelectedMaquetteModel = maquetteName;
+            var maquette = manager.GetMaquetteByName(maquetteName.NomMaquette);
 
             var parametre = new Dictionary<string, Object>
             {
-                {"maquette",maquette }
+                {"maquette",maquette}
             };
 
             await Shell.Current.GoToAsync($"{nameof(BlockView)}",parametre);

src/CalculateurMoyanne/CalculateurEF/Entities/BlocEntity.cs

@@ -13,7 +13,7 @@ namespace CalculateurEF.Entities
         public int Id { get; set; }
         public string Nom { get; set; }
         public ICollection<UEentity> UeEntityId { get; set; } = new List<UEentity>();
-
+       
         public int IDMaquetteFrk
         {
             get; set;
@@ -24,6 +24,8 @@ namespace CalculateurEF.Entities
             get; set;
         }
 
+       
+
         
 
 

src/CalculateurMoyanne/CalculateurEF/Entities/MaquetteEntity.cs

@@ -13,6 +13,7 @@ namespace CalculateurEF.Entities
         #region Propriétés
         public int Id { get; set; }
         public string NomMaquette { get; set; }
+
         public ICollection<BlocEntity> Bloc { get; set; }= new List<BlocEntity>();
        // public ICollection<UEentity> UeEntityId { get; set; } = new List<UEentity>();
 

src/CalculateurMoyanne/CalculateurMapping/BlocDbDataManager.cs

@@ -5,6 +5,7 @@ using ClassCalculateurMoyenne;
 using Microsoft.EntityFrameworkCore;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -21,10 +22,13 @@ namespace CalculateurMapping
                 BlocEntity entity = new BlocEntity
                 {
                     Nom = blc.GetNom(),
-                    IDMaquetteFrk=blc.IDMaquetteFrk
+                   // IDMaquetteFrk=blc.IDMaquetteFrk
                 };              
                     context.Bloc.Add(entity);
-                    context.SaveChanges();
+
+                try { await context.SaveChangesAsync(); }
+                catch (Exception e) { Debug.WriteLine("ex"); }
+                    //context.SaveChanges();
                     resultat = true;
             }
             return resultat;

src/CalculateurMoyanne/CalculateurMapping/MaquetteDbDataManager.cs

@@ -11,7 +11,7 @@ using System.Threading.Tasks;
 
 namespace CalculateurMapping
 {
-    public class MaquetteDbDataManager<TContext> : IDataManager<MaquetteModel> where TContext : CalculContext, new()
+    public class MaquetteDbDataManager<TContext> : IMaquetteDbManager where TContext : CalculContext, new()
     {
         public MaquetteDbDataManager()
         {
@@ -37,6 +37,52 @@ namespace CalculateurMapping
             }
             
         }
+        //ajt de bloc
+
+        public async Task<bool> AddBlocmaquette(MaquetteModel mqt,BlocModel blocModel)
+        { //Add mqt
+
+            bool result = false;
+            using (var context = new TContext())
+            {
+                MaquetteEntity data = await context.Maquettes.FindAsync(mqt.Id);
+                if (data != null)
+                {
+                    BlocEntity entity = new BlocEntity
+                    {
+                        Id = blocModel.Id,
+                        MaquetteEntity = new MaquetteEntity
+                        {
+                            Id = mqt.Id,
+                            NomMaquette = mqt.NomMaquette
+                        },
+
+                    };
+
+                    if (!data.Bloc.Contains(entity))
+                    {
+                        data.Bloc.Add(entity);
+                        await context.Bloc.AddAsync(entity); 
+                    //    context.Maquettes.Update(data);
+                    
+                      await  context.SaveChangesAsync();
+                    }
+                }
+                //context.Database.EnsureCreated();
+               
+                return result;
+
+            }
+
+
+
+        }
+
+
+
+
+
+
         //delete maquette
         public async Task<bool> Delete(MaquetteModel maquette)
         {
@@ -120,10 +166,10 @@ namespace CalculateurMapping
             using (var context = new TContext())
             {
                 List<MaquetteModel> maquettes = new List<MaquetteModel>();
-                foreach (var item in await context.Maquettes.ToListAsync())
+                foreach (var item in context.Maquettes.Include(m => m.Bloc)) 
                 {
                   //  Console.WriteLine(item);
-                    maquettes.Add(new MaquetteModel(item.Id, item.NomMaquette));
+                    maquettes.Add(new MaquetteModel(item.Id, item.NomMaquette,new List<UE>(),item.Bloc.Select(b=>new BlocModel(b.Nom)).ToList()));
                 }
                 return maquettes;
             }

src/CalculateurMoyanne/CalculateurStub/Stub/StubMaquette.cs

@@ -9,7 +9,7 @@ using Bussness;
 
 namespace StubCalculateur.Stub
 {
-    public class StubMaquette: IDataManager<MaquetteModel>
+    public class StubMaquette: IMaquetteDbManager
     {
         private List<BlocModel> listb = new List<BlocModel>();
         public List<UE> ues = new List<UE>();
@@ -85,5 +85,10 @@ namespace StubCalculateur.Stub
         {
             throw new NotImplementedException();
         }
+
+        public Task<bool> AddBlocmaquette(MaquetteModel mqt, BlocModel blocModel)
+        {
+            throw new NotImplementedException();
+        }
     }
 }