public static CategorieViewModel getCategorie(int idCategorie)
{
CategorieDAO pDAO = CategorieDAO.getCategorie(idCategorie);
CategorieViewModel p = new CategorieViewModel(pDAO.id_categorie, pDAO.nom);
return(p);
}
void loadCategories()
{
lp = CategorieORM.listeCategories();
myDataObject = new CategorieViewModel();
//LIEN AVEC la VIEW
/*listeCategories.ItemsSource = lp; // bind de la liste avec la source, permettant le binding.*/
}
public EventoModifica(Guid Id)
{
InitializeComponent();
categorieViewModel = new CategorieViewModel();
viewModel = new EventoDetailViewModel();
EventoId = Id;
}
public static CategorieViewModel getCategorie(int id)
{
CategorieDAO pDAO = CategorieDAO.getCategorie(id);
CategorieViewModel p = new CategorieViewModel(pDAO.idDAO, pDAO.nomCategorieDAO);
return(p);
}
void loadCategorie()
{
Categorie = CategorieORM.listeCategorie();
myDataObjectCategorie = new CategorieViewModel();
//LIEN AVEC la VIEW
categorieCombobox.ItemsSource = Categorie; // bind de la liste avec la source, permettant le binding.#2#*/
}
private void Rename_Categorie_Click(object sender, RoutedEventArgs e)
{
this.IsEnabled = false;
this.Opacity = 0.2;
Popup add = new Popup();
CategorieViewModel cvm = (sender as MenuItem).DataContext as CategorieViewModel;
Categorie ca = new Categorie()
{
Id = cvm.Id
};
CategoriePopupRename popup = new CategoriePopupRename(ca, categories);
popup.Width = Application.Current.Host.Content.ActualWidth - 40;
add.Child = popup;
add.IsOpen = true;
add.VerticalOffset = 50;
add.HorizontalOffset = 20;
add.Closed += (s1, e1) =>
{
this.Opacity = 1;
this.IsEnabled = true;
//RefreshItems();
};
popup.TxtName.Text = cvm.Name;
}
public static CategorieViewModel CategorieEditViewModel(Categorie categorie)
{
CategorieViewModel categorieView = new CategorieViewModel()
{
titel = categorie.titel,
id = categorie.id,
};
categorieView.products = new List <ProductViewModel>();
foreach (Product product in categorie.GetProducts())
{
ProductViewModel prodcutView = new ProductViewModel()
{
id = product.id,
titel = product.titel
};
categorieView.products.Add(prodcutView);
}
categorieView.productsNotInCategorie = new List <ProductViewModel>();
foreach (Product product in categorie.GetProductsNotInCategorie())
{
ProductViewModel prodcutView = new ProductViewModel()
{
id = product.id,
titel = product.titel
};
categorieView.productsNotInCategorie.Add(prodcutView);
}
return(categorieView);
}
private void Remove_Categorie_Click(object sender, RoutedEventArgs e)
{
CategorieViewModel cvm = (sender as MenuItem).DataContext as CategorieViewModel;
categorieRepo.DeleteCategorie(cvm.Id);
categories.Remove(cvm);
}
public static Categorie Categorie(CategorieViewModel categorieView)
{
return(new Categorie()
{
id = categorieView.id,
titel = categorieView.titel
});
}
void loadCategories()
{
ca = CategorieORM.listeCategories();
myDataObjectCategorie = new CategorieViewModel();
ComboBoxCategorie.ItemsSource = ca;
//LIEN AVEC la VIEW
/*listeAchats.ItemsSource = lp; // bind de la liste avec la source, permettant le binding.*/
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
OndernemingviewModel = new OndernemingenViewModel();
CategorieViewModel = new CategorieViewModel();
gebruikerViewModel = new GebruikerViewModel();
fillPage();
}
public IActionResult Categorie(int id)
{
Categorie categorie = categorieContainer.GetByID(id);
CategorieViewModel categorieViewModel = CategorieMapper.CategorieViewModel(categorie);
return(View(categorieViewModel));
}
public IActionResult Create(CategorieViewModel categorieModel)
{
Categorie newCategorie = CategorieMapper.Categorie(categorieModel);
categorieContainer.AddNew(newCategorie);
return(RedirectToAction("Index", CategorieMapper.AllCategorieViewModels()));
}
private void Remove_Item_Click(object sender, RoutedEventArgs e)
{
ItemViewModel ivm = (sender as MenuItem).DataContext as ItemViewModel;
CategorieViewModel cvm = categories.Where(c => c.Id == ivm.CategorieId).FirstOrDefault();
itemRepo.DeleteItem(ivm.Id);
cvm.Items.Remove(ivm);
}
void loadCategories()
{
lc = CategorieORM.listeCategories();
myDataObjectCategorie = new CategorieViewModel();
ComboBoxCategorie.ItemsSource = lc;
//LIEN AVEC la VIEW
//List_Categorie.ItemsSource = lp; // bind de la liste avec la source, permettant le binding.
}
public IActionResult Edit(CategorieViewModel categorieModel)
{
Categorie categorie = CategorieMapper.Categorie(categorieModel);
categorie.Update();
categorie = categorieContainer.GetByID(categorie.id);
categorieModel = CategorieMapper.CategorieEditViewModel(categorie);
return(RedirectToAction("Categorie", categorieModel));
}
public IActionResult Index()
{
CategorieViewModel vm = new CategorieViewModel();
List <Categorie> categories = new List <Categorie>();
categories = categorieRepository.GetAll();
vm.CategorieDetailViewModels = converter.ModelsToViewModels(categories);
return(View(vm));
}
private void Btn_Sppr(object sender, RoutedEventArgs e)
{
if (List_Categorie.SelectedItem is CategorieViewModel)
{
CategorieViewModel toRemove = (CategorieViewModel)List_Categorie.SelectedItem;
lp.Remove(toRemove);
List_Categorie.Items.Refresh();
CategorieORM.supprimerCategorie(selectedCategorieId);
}
}
public IActionResult RemoveProduct(int categorieId, int productId)
{
Categorie categorie = categorieContainer.GetByID(categorieId);
categorie.RemoveProduct(productId);
CategorieViewModel categorieViewModel = CategorieMapper.CategorieEditViewModel(categorie);
return(RedirectToAction("Edit", categorieViewModel));
}
private void SupprButton(object sender, RoutedEventArgs routedEventArgs)
{
if (listeCategorie.SelectedItem is CategorieViewModel)
{
CategorieViewModel toRemove = (CategorieViewModel)listeCategorie.SelectedItem;
lp.Remove(toRemove);
listeCategorie.Items.Refresh();
CategorieORM.supprimerCategorie(selectedCategorieId);
}
}
private void supprimerButton_Click(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
if (listeCategories.SelectedItem is CategorieViewModel)
{
CategorieViewModel toRemove = (CategorieViewModel)listeCategories.SelectedItem;
c.Remove(toRemove);
listeCategories.Items.Refresh();
CategorieORM.supprimerCategorie(selectedCategorieId);
}
}
public async Task <IActionResult> DeleteCategorieConfirmed([Bind("CategorieId")] CategorieViewModel categViewModel)
{
int id = categViewModel.CategorieId;
var categorie = await _context.Categories.SingleOrDefaultAsync(m => m.CategorieId == id);
_context.Categories.Remove(categorie);
await _context.SaveChangesAsync();
TempData["message"] = $"Categorie '{categorie.Nom}' has been deleted.";
return(RedirectToAction(nameof(Index)));
}
private void BtnAfficherProd(object sender, RoutedEventArgs e)
{
cp = CategorieORM.getNomCategorie(Convert.ToInt32(ComboBoxCategorie.SelectedValue.ToString()));
myDataObjectCP = new CategorieViewModel();
listeCP.ItemsSource = cp;
listeCP.DataContext = myDataObjectCP;
listeCP.Items.Refresh();
}
public static ObservableCollection <CategorieViewModel> listeCategorie()
{
ObservableCollection <CategorieDAO> lDAO = CategorieDAO.listeCategorie();
ObservableCollection <CategorieViewModel> l = new ObservableCollection <CategorieViewModel>();
foreach (CategorieDAO element in lDAO)
{
CategorieViewModel p = new CategorieViewModel(element.idDAO, element.nomCategorieDAO);
l.Add(p);
}
return(l);
}
private void nomCategorieButton_Click(object sender, RoutedEventArgs e)
{
myDataObjectCategorie.idProperty = CategorieDAL.getMaxIdCategorie() + 1;
c.Add(myDataObjectCategorie);
CategorieORM.insertCategorie(myDataObjectCategorie);
compteur = c.Count();
listeCategories.Items.Refresh();
myDataObjectCategorie = new CategorieViewModel();
nomCategorieButton.DataContext = myDataObjectCategorie;
nomTextBox.DataContext = myDataObjectCategorie;
}
// GET: Search
public JsonResult GetCategorie()
{
List <CategorieViewModel> cvms = new List <CategorieViewModel>();
foreach (var a in db.Food_categories.ToList())
{
CategorieViewModel cvm = new CategorieViewModel();
cvm.name = a.name;
cvm.Id = a.Id;
cvms.Add(cvm);
}
return(Json(cvms, JsonRequestBehavior.AllowGet));
}
async void Delete()
{
var response = await dialogService.ShowConfirm(
"Confirm",
"Are you sure to delete this Category ?");
if (!response)
{
return;
}
await CategorieViewModel.GetInstance().Delete(this);
}
public async Task <IActionResult> DeleteCategorie([FromBody] CategorieViewModel categorieViewModel)
{
User user = await userManager.GetUserAsync(HttpContext.User);
var categorie = new Categorie
{
Name = categorieViewModel.Name,
User = user,
IsExpense = categorieViewModel.IsExpense
};
return(Json(new { succeed = categorieRepository.DeleteCategorie(categorie) }));
}
private void btnAjouter(object sender, RoutedEventArgs e)
{
myDataObject.id = CategorieDAL.getMaxIdCategorie() + 1;
lp.Add(myDataObject);
CategorieORM.insertCategorie(myDataObject);
compteur = lp.Count();
// Comme on a inséré une Categorie, on crée un nouvel objet CategorieViewModel
// Et on réatache tout ce qu'il faut pour que la vue soit propre
myDataObject = new CategorieViewModel();
// Comme le contexte des élément de la vue est encore l'ancien CategorieViewModel,
// On refait les liens entre age, slider, textbox, bouton et le nouveau CategorieViewModel
nom.DataContext = myDataObject;
}
public static List <CategorieViewModel> AllCategorieViewModels()
{
CategorieContainer categorieContainer = new CategorieContainer();
List <CategorieViewModel> categorieViewModels = new List <CategorieViewModel>();
foreach (Categorie categorie in categorieContainer.GetAll())
{
CategorieViewModel categorieView = new CategorieViewModel()
{
titel = categorie.titel,
id = categorie.id
};
categorieViewModels.Add(categorieView);
}
return(categorieViewModels);
}
private void ajoutCategorieANouvelleTache(TacheViewModel tacheVM)
{
ObservableCollection<CategorieViewModel> listCatVM = new ObservableCollection<CategorieViewModel>();
// Création de la nouvelle liste de catégorie
foreach (var cat in Menu.ListeCategoriesMenuVM)
{
CategorieViewModel catVM = new CategorieViewModel(new VOCategorie() { Nom = cat.NomCategorie });
listCatVM.Add(catVM);
}
tacheVM.CategoriesProjet = listCatVM;
}
/*private void AjouterPersonne(VOProjet projet)
{
foreach (var taches in listeTachesViewModel)
{
//ObservableCollection<PersonneViewModel> personneProjetTemp = new ObservableCollection<PersonneViewModel>();
if (taches.PersonneProjet.Count != 0)
{
//foreach (var pers in taches.PersonneProjet)
//{
foreach (var personne in Menu.Personnes)
{
if (personne.Nom != null )
{
PersonneViewModel p2 = new PersonneViewModel();
p2.Nom = personne.Nom;
p2.Affecte = false;
taches.PersonneProjet.Add(p2);
}
}
//}
}
else
{
foreach (var personne in Menu.Personnes)
{
if (personne.Nom != null)
{
PersonneViewModel p2 = new PersonneViewModel();
p2.Nom = personne.Nom;
p2.Affecte = false;
taches.PersonneProjet.Add(p2);
}
}
}
}
}*/
/// <summary>
///
/// </summary>
/// <param name="categorieMenu"></param>
private void AjoutCategorieDuMenuAuxTaches(ObservableCollection<CategoriesMenuViewModel> categorieMenu)
{
ObservableCollection<CategorieViewModel> list = new ObservableCollection<CategorieViewModel>();
foreach (var cat in categorieMenu)
{
if (!string.IsNullOrEmpty(cat.NomCategorie))
{
CategorieViewModel catgrie = new CategorieViewModel(new VOCategorie() { Nom = cat.NomCategorie });
list.Add(catgrie);
}
}
foreach (var tachVM in listeTachesViewModel)
{
// CategorieViewModel cat = new CategorieViewModel(new VOCategorie());
tachVM.CategoriesProjet = list;
}
}
/// <summary>
/// Permet d'ajouter une catégorie
/// </summary>
/// <param name="categorieVM">la catégorie à ajouter</param>
public void AjouterCategorie(CategorieViewModel categorieVM)
{
CategoriesProjet.Add(categorieVM);
categorieVM.CheckBoxCocheChanged += AjoutCategorieViewModel;
}
/// <summary>
/// Permet d'ajouter les catégories du Menu à chaque tâche
/// </summary>
/// <param name="categories">Collection de catégories</param>
private void AjoutCategorieProjet(ObservableCollection<VOCategorie> categories)
{
// Ajout des catégories du projet à chaque tacheViewModel
foreach (var tache in ListeTachesViewModel)
{
if (categories != null)
{
foreach (var categorie in /*Menu.CategoriesProjet*/categories)
{
// this.Menu.ListeCategoriesMenuVM.Add(new CategoriesMenuViewModel(categorie));
CategorieViewModel catVM = new CategorieViewModel();
catVM.Nom = categorie.Nom;
tache.AjouterCategorie(catVM);
}
if (tache.ListeCategoriesTache != null)
{
foreach (var categorieTache in tache.ListeCategoriesTache)
{
foreach (var categorieProjet in tache.CategoriesProjet)
{
if (categorieProjet.Nom.Equals(categorieTache))
{
categorieProjet.CheckOuverture = true;
categorieProjet.Check = true;
categorieProjet.CheckOuverture = false;
}
}
}
}
}
}
}
/// <summary>
/// Ajoute une catégorie cochée à la tache
/// </summary>
/// <param name="categorieVM">La catégorie cochée</param>
private void AjoutCategorieViewModel(CategorieViewModel categorieVM)
{
if (categorieVM.Check)
{
ListeCategoriesTache.Add(categorieVM.Nom);
}
else
{
ListeCategoriesTache.Remove(categorieVM.Nom);
}
}
