methode remove dans une collection

**chlock62** · 03/12/2014, 16h54

Bonjour, je m'explique:

J'ai une entité Cart:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
<?php
 
/* 
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
namespace Frontend\PanierBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
 
 
/**
*    @ORM\entity
*    @ORM\Table(name="cart")
*/
class Cart {
 
 
/** @ORM\Id
*  @ORM\Column(type="integer")
*  @ORM\GeneratedValue
*/
private $id;
 
 
/**
* @ORM\OneToMany(targetEntity="CartProduct", mappedBy="cart",cascade={"persist", "remove"})
*/
 
private $cart_product;
 
/** @ORM\Column(name="created_at", type="string", length=255) */
private $createdAt;
    /**
     * Constructor
     */
    public function __construct()
    {
        $this->cart_product = new \Doctrine\Common\Collections\ArrayCollection();
    }
 
    /**
     * Get id
     *
     * @return integer 
     */
    public function getId()
    {
        return $this->id;
    }
 
    /**
     * Add cart_product
     *
     * @param \Frontend\PanierBundle\Entity\CartProduct $cartProduct
     * @return Cart
     */
    public function addCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
    {
        $this->cart_product[] = $cartProduct;
 
        return $this;
    }
 
    /**
     * Remove cart_product
     *
     * @param \Frontend\PanierBundle\Entity\CartProduct $cartProduct
     */
    public function removeCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
    {
        $this->cart_product->removeElement($cartProduct);
    }
 
    /**
     * Get cart_product
     *
     * @return \Doctrine\Common\Collections\Collection 
     */
    public function getCartProduct()
    {
        return $this->cart_product;
    }
 
    /**
     * Set createdAt
     *
     * @param string $createdAt
     * @return Cart
     */
    public function setCreatedAt($createdAt)
    {
        $this->createdAt = $createdAt;
 
        return $this;
    }
 
    /**
     * Get createdAt
     *
     * @return string 
     */
    public function getCreatedAt()
    {
        return $this->createdAt;
    }
 
    public function __sleep()
    {
        return array('id','createdAt','cart_product');
    }
    public function __wakeup() {
    }
   public function __toString() {
        return  (string)$this->id;
    }
}

puis une entite Cart_product les unis par une collection de Cart_product par l'entite Cart "OneToMany"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
<?php
 
/* 
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
namespace Frontend\PanierBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
 
/**
*    @ORM\Entity(repositoryClass="Frontend\PanierBundle\Entity\CartProductRepository")
*    @ORM\Table(name="cart_product")
*/
class CartProduct {
    //put your code here
 
     /**
     *    @ORM\GeneratedValue
     *    @ORM\Id
     *   @ORM\Column(type="integer")
     */
    private $id;
 
 
    /**
    * @ORM\ManyToOne(targetEntity="Cart",inversedBy="id")
     * 
     */
     private $cart;
 
     /**

     * @ORM\ManyToOne(targetEntity="\Frontend\CatalogueBundle\Entity\Produit",inversedBy="id")
     * 
     */
    private $leProduit;
 
 
    /** @ORM\Column(type="integer")
    *
    */
    private $quantite;
    /**
     * Get id
     *
     * @return integer 
     */
    public function getId()
    {
        return $this->id;
    }
 
    /**
     * Set cart
     *
     * @param \Frontend\PanierBundle\Entity\Cart $cart
     * @return CartProduct
     */
    public function setCart(\Frontend\PanierBundle\Entity\Cart $cart = null)
    {
        $this->cart = $cart;
 
        return $this;
    }
 
    /**
     * Get cart
     *
     * @return \Frontend\PanierBundle\Entity\Cart 
     */
    public function getCart()
    {
        return $this->cart;
    }
 
    /**
     * Set leProduit
     *
     * @param \Frontend\CatalogueBundle\Entity\Produit $leProduit
     * @return CartProduct
     */
    public function setLeProduit(\Frontend\CatalogueBundle\Entity\Produit $leProduit = null)
    {
        $this->leProduit = $leProduit;
 
        return $this;
    }
 
    /**
     * Get leProduit
     *
     * @return \Frontend\CatalogueBundle\Entity\Produit 
     */
    public function getLeProduit()
    {
        return $this->leProduit;
    }
 
    /**
     * Set quantite
     *
     * @param integer $quantite
     * @return CartProduct
     */
    public function setQuantite($quantite)
    {
        $this->quantite = $quantite;
 
        return $this;
    }
 
    /**
     * Get quantite
     *
     * @return integer 
     */
    public function getQuantite()
    {
        return $this->quantite;
    }
   public function __sleep()
    {
        return array('id','cart','quantite');
    }
    public function __wakeup() {
    }
 
}

Pour commence je fais l'exemple d'ajouter une nouvelle instance de Cart ainsi qu'une nouvelle instance de Cart_product en persistant l'instance de Cart_product par l'instance de classe Cart

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$cart_product = CartProduct()
$cart_product->setQuantite(1);
 
$cart = new Cart()
$cart->setCreatedAt(date("F j, Y, g:i a"));
$cart_product->setCart($cart);
 
$cart->addCartProduct($cart_product);//insertion d'une nouvelle ligne dans la collection cartproduct
/*public function addCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
    {
        $this->cart_product[] = $cartProduct;
    
        return $this;
    }*/
$this->em->persist($cart);
$this->em->flush();

Pour les action ci-dessus tout fonctionne a merveille j'ai bien mon enregistrement en base pour le Cart ainsi que l'enregistrement Cart_product correspondant au Cart

Mais maintenant je voudrais supprimer l'enregistrement Cart_product précédemment créé en réalisant les action ci'-dessous
//je récupére mon objet Cart

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 $cart = $this->em->getRepository('MonBundle:Cart')->find(2);
 
//je récupére mon objet Cart_product
 $cart_product = $this->em->getRepository('MonBundle:Cart')->find(3);
 
 
$cart->removeCartProduct($cart_product);   
$cart->setCreatedAt(date("F j, Y, g:i a"));
$this->em->persist($cart);
$this->em->flush();
 
//en faisant un affichage de la collection de cart_product, je vois bien que le cart-product a été supprimé
var_dump( $cart->getCartProduct()->getValues());

mais hélas pas en base de donné donc je comprend pas pourquoi la methode $cart->removeCartProduct($cart_product); ne supprimé pas en base?

J'ai cela dit essayé avec la methode $this->em->remove($cart_product); et la ca focntionne mais la methode
$cart->removeCartProduct($cart_product) sert bien à supprimer un objet cart-product d'une collection par l'objet Cart

Une idée les amis

Merci à tous

**Nico_F** · 03/12/2014, 17h33

Hello,

Si tu souhaites que le changement de l'objet Cart influe sur un ou plusieurs objet de sa collection, il faut que le OwningSide de la relation soit sur l'entité Cart et non sur Cart_product.

Le owning side étant celui qui possède l'annotation inversedBy. Dans ton cas il se trouve du coté du produit, ce qui n'est pas logique : persister un produit ne doit pas persister le caddie. C'est lorsque tu persistes le caddie que les changements doivent se répercuter sur les produits.

http://doctrine-orm.readthedocs.org/...ociations.html

**lilalex** · 03/12/2014, 18h35

Salut Nico_F,

Je suis sûr et certain à 50% que c'est la table qui a la clé étrangère qui est le owning side, donc CartProduct en l’occurrence.

Alex

**Nico_F** · 04/12/2014, 10h16

Au temps pour moi, tu as raison j'ai lu un peu trop rapidement la doc (ainsi que son problème).
J'avais zappé cette partie.

ManyToOne is always the owning side of a bidirectional association.
OneToMany is always the inverse side of a bidirectional association.

C'est une relation bidirectionnelle, donc soit tu bascules sur une relation unidirectionnelle, soit tu modifies les méthodes addProduct et removeProduct (je sens le problème viens de là : peux-tu nous les montrer ?) en ajoutant un $product->setCart($this); pour le add ou un $product->setCart(null); pour le remove.

**chlock62** · 04/12/2014, 10h33

Salut Nico_F, oui en effet j'ai rien compris au message précédent.

Donc tu veu voir les methodes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
<?php
 
/* 
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
namespace Frontend\PanierBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
 
 
/**
*    @ORM\entity
*    @ORM\Table(name="cart")
*/
class Cart {
 
 
/**
* @ORM\OneToMany(targetEntity="CartProduct", mappedBy="cart",cascade={"persist", "remove"})
*/
 
private $cart_product;
 
    /**
     * Constructor
     */
    public function __construct()
    {
        $this->cart_product = new \Doctrine\Common\Collections\ArrayCollection();
    }
 
 
    /**
     * Add cart_product
     *
     * @param \Frontend\PanierBundle\Entity\CartProduct $cartProduct
     * @return Cart
     */
    public function addCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
    {
        $this->cart_product[] = $cartProduct;
 
        return $this;
    }
 
    /**
     * Remove cart_product
     *
     * @param \Frontend\PanierBundle\Entity\CartProduct $cartProduct
     */
    public function removeCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
    {
        $this->cart_product->removeElement($cartProduct);
    }
 
 
}

De plus omme je disais dans les message précédent le fait de vouloir ajouter un objet dans la collection "cart_product" en persistant un l'objet "cart" et que l'ajout soit pris en compte en mémoire et en base fonctionne parfaitement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
$cart = $this->em->getRepository('FrontendPanierBundle:Cart')->find(1);
$cart_product = $this->em->getRepository('FrontendPanierBundle:CartProduct')->find(2);
 
$cart_product = CartProduct()
$cart_product->setQuantite(1);
 
$cart = new Cart()
$cart->setCreatedAt(date("F j, Y, g:i a"));
$cart_product->setCart($cart);
 
$cart->addCartProduct($cart_product);//insertion d'une nouvelle ligne dans la collection cartproduct
/*public function addCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
    {
        $this->cart_product[] = $cartProduct;
 
        return $this;
    }*/
$this->em->persist($cart);
$this->em->flush();

C'est dans le cas de la suppression l'objet et bien supprimer en mémoire mais pas en base de donnée

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 $cart = $this->em->getRepository('FrontendPanierBundle:Cart')->find(1);
 $cart_product = $this->em->getRepository('FrontendPanierBundle:CartProduct')->find(2);
 
 var_dump( $cart->getCartProduct()->getValues());exit;//ce var_dump affiche la collection avec un seul objet "$cart_product" dans la collection "cart_product"         
 
        //$cart->removeCartProduct($cart_product);   //je supprime
        $cart_product->setQuantite(10);
        $cart->setCreatedAt(date("F j, Y, g:i a"));
        $this->em->persist($cart);
        $this->em->flush();
 
 var_dump( $cart->getCartProduct()->getValues());exit;

ce var_dump affiche la collection vide, l'objet "$cart_product" de la collection "cart_product" a bien été supprimer, mais élas rien n'est supprimer en base de donnée

**Nico_F** · 04/12/2014, 11h31

De plus omme je disais dans les message précédent le fait de vouloir ajouter un objet dans la collection "cart_product" en persistant un l'objet "cart" et que l'ajout soit pris en compte en mémoire et en base fonctionne parfaitement:

Oui, ça fonctionne car dans ton controller tu fais l'affectation dans les deux sens :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$cart_product->setCart($cart);
$cart->addCartProduct($cart_product);

En réalité, la première ligne devrait se trouver dans la méthode addCartProduct().

Modifie ces deux méthodes comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public function addCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
{
    $cartProduct->setCart($this);
    $this->cart_product[] = $cartProduct;
 
    return $this;
}
 
public function removeCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
{
    $cartProduct->setCart(NULL);
    $this->cart_product->removeElement($cartProduct);
 
    return $this;
}

De cette manière tu n'auras plus besoin de setter le cart dans ton controller.

**chlock62** · 04/12/2014, 11h53

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
        public function addCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
        {
            $cartProduct->setCart($this);
            $this->cart_product[] = $cartProduct;
 
            return $this;
        }
 
        public function removeCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
        {
            $cartProduct->setCart(NULL);
            $this->cart_product->removeElement($cartProduct);
 
            return $this;
        }
 De cette manière tu n'auras plus besoin de setter le cart dans ton controller.

Oui c'est bien beau de me faire gagner une ligne dans le controller mais bon, de plus pour la methode "$cartProduct->setCart(NULL);"
maintenant au lieu d'avoir le cart en clé étrangère dans le cart_product en base j'ai NULL au lieu du cart référencé en clé étrangère, mais la ligne cart_product est toujours existante?
le systéme de mettre Null peut etre intéréssant pour plus avoir de relation, donc elle ne sera plus présente dans la collection cart_product, je suis d'accord, mais par default symfony créer la methode "removeCartProduct()", ici tu me dit de la modifier, ca me plai pas trop mais bon!, donc quelle est l'objectif de la methode $this->cart_product->removeElement($cartProduct);?

**Nico_F** · 04/12/2014, 12h23

Oui c'est bien beau de me faire gagner une ligne dans le controller mais bon, de plus pour la methode "$cartProduct->setCart(NULL);

On se calme deux minutes et on réfléchit : le controller moins il a de code, mieux il se porte. De plus c'est pas un traitement qui est propre à cette action : partout ou tu voudras ajouter/retirer un élément à ton panier tu devras faire ça. Donc ça n'a pas sa place dans le controller mais bel et bien dans les méthodes d'ajout/suppression.

maintenant au lieu d'avoir le cart en clé étrangère dans le cart_product en base j'ai NULL au lieu du cart référencé en clé étrangère, mais la ligne cart_product est toujours existante?

Mhmm c'est normal : quand dans la vraie vie tu retires un article de ton caddie il existe toujours : en dehors de ton caddie, il ne se désintègre pas par combustion spontanée. La méthode removeCartProduct retire l'association qui se trouve entre cart et cartProduct. Si tu ne veux pas qu'un produit puisse exister sans sa clé étrangère cart il y a l'annotation orphanRemoval="true" qui permettra après avoir sorti le produit de ton panier de dire "Si après le flush mon produit se retrouve sans caddie je le supprime".

le systéme de mettre Null peut etre intéréssant pour plus avoir de relation, donc elle ne sera plus présente dans la collection cart_product, je suis d'accord, mais par default symfony créer la methode "removeCartProduct()", ici tu me dit de la modifier, ca me plai pas trop mais bon!

Si ça ne te plait pas, tu peux aussi ne pas le faire, rester avec ton problème, et faire ce qui doit de toute façon être fait mais au mauvais endroit.
Mettre NULL permet effectivement de ne plus avoir de relation entre ton caddie et ton produit. Et il me semble qu'avant de supprimer le produit c'est bien ce qu'il faut faire. Et ça réponds à ta dernière question : la méthode $this->cart_product->removeElement($cartProduct); est supposée retirer le produit que tu lui passe du caddie.
Mais à aucun moment de supprimer cet objet.

**chlock62** · 04/12/2014, 14h02

je prend analyse de toutes les informations que tu me donne et je te remercie.

Juste un détail pour précision:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Mhmm c'est normal : quand dans la vraie vie tu retires un article de ton caddie il existe toujours : en dehors de ton caddie, il ne se désintègre pas par combustion spontanée. La méthode removeCartProduct retire l'association qui se trouve entre cart et cartProduct. Si tu ne veux pas qu'un produit puisse exister sans sa clé étrangère cart il y a l'annotation orphanRemoval="true" qui permettra après avoir sorti le produit (je ne sort pas de produit du panier mais je supprime une ligne qui elle référence un produit par la clé le leProduit) de ton panier de dire "Si après le flush mon produit( non le produit mais la ligne cart_product) se retrouve sans caddie je le supprime".

J'ai coloré en rouge ce que je vais expliqué ci-dessous
un article et référencé par clé étrangère dans la l'entité cart_product par $leProduit pour le produit et $cart pour le caddie.

C'est une ligne cart_product que je veux supprimer non un produit

Pour moi le cart_product est une ligne de panier:

Par exemple la table cart_product en base donne: les enregistrement que je souhaite supprimer par la methode "$cart->removeCartProduct($cart_product);"
donc c'est pour ca que de mettre null ci-dessous pour le champ(attribut) (cart_id) supprime bien la relation donc, donc la collection" getCartProduct () ne référencera plus la ligne "cart_product", je suis d'accord et ça pourrais me convenir.

Mais si tu as compris mon raisonnement sur l’entité cart_product et non l’entité Produit dont tu coyer que j'en souhaiter la suppression reste toujours en base, pas dérangeant mais elle n'as plus aucune utilité

Nom : cart_product.png
Affichages : 833
Taille : 8,8 Ko

Nom : cart_product.png
Affichages : 833
Taille : 8,8 Ko

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
      /**
 
     * @ORM\ManyToOne(targetEntity="\Frontend\CatalogueBundle\Entity\Produit",inversedBy="id")
     * 
     */
    private $leProduit;

un cart est et référencé par clé étrangère dans la l'entité cart_product par $cart

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
/**
    * @ORM\ManyToOne(targetEntity="Cart",inversedBy="id")
     * 
     */
     private $cart;

Cela la dit tu m'as bien avancé sur certaine chose.

j’espère que tu va comprendre mon mon blabla

Merci en tout cas

**Nico_F** · 04/12/2014, 14h20

D'accord, donc je confirme que c'est bien orphanRemoval que tu dois rajouter.
En faisant un ->setCart(NULL) tu dissocies la ligne du caddie. Au moment de faire le flush, les choses se déroulent dans cet ordre.
Chacun des produits est flushé :
- S'il y a des nouveaux cart_products qui ont un cart_id, ils sont enregistrés et appartiennent à la collection de l'objet cart.
- S'il y a des cart_products existants qui n'ont pas de cart_id, on vérifie la présence de l'annotation orphanRemoval : quand cette valeur est à true on supprime la ligne cart_product qui n'a pas lieu d'exister s'il elle ne possède pas un cart_id.

=> Les deux méthodes add et remove que je t'ai fournies sont bonnes, et tu dois rajouter l'annotation orphanRemoval="true" sur l'attribut OneToMany cart_products.

++

**chlock62** · 04/12/2014, 14h33

oui nous nous somme compris

regarde cette article:

http://devblog.lexik.fr/tips/orphanr...doctrine2-2020

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

=> Les deux méthodes add et remove que je t'ai fournies sont bonnes, et tu dois rajouter l'annotation orphanRemoval="true" sur l'attribut OneToMany cart_products.

Je pense plutot le cart non c'est dans le cart ma collection de cart_product, de plus je dois enlever les double cote "" de true sinon j'ai l'erreur suivante ca te parle:
/**
* @ORM\OneToMany(targetEntity="CartProduct", mappedBy="cart",cascade={"persist", "remove"},orphanRemoval= "true")
*/

private $cart_product;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Fatal error: Uncaught exception 'Doctrine\Common\Annotations\AnnotationException' with message '[Type Error] Attribute "orphanRemoval" of @ORM\OneToMany declared on property Backend\CommandeBundle\Entity\Cart::$cart_product expects a(n) boolean, but got string.' in blablabla\vendor\doctrine\annotations\lib\Doctrine\Common\Annotations\AnnotationException.php on line 97

orphanRemoval= true

**Nico_F** · 04/12/2014, 14h42

Oui sans les quotes autour de true, pardon.

Et oui c'est ce que je voulais dire : dans la classe cart, sur l'attribut cart_product.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
/**
 * @ORM\OneToMany(targetEntity="CartProduct", mappedBy="cart", cascade={"persist", "remove"}, orphanRemoval=true)
 */
private $cart_product;

**chlock62** · 04/12/2014, 14h46

Bon c parfait l'ami donc si j'ai bien compris et en résumé:

je met à null le cart_id de la ligne cart_products
$cart_products->setCart(NULL) //tu dissocies la ligne du caddie.

Au moment de faire le flush, les choses se déroulent dans cet ordre:

il vérifie tous les cart_product et si il tombe sur des car_id à null et grâce a l'annotation "orphanRemoval ", il supprime

?

**chlock62** · 04/12/2014, 14h54

la présence de cette cette instruction n'est pas indispensable:

Code : Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$cart_products->setCart(NULL) //tu dissocies la ligne du caddie.

je l'ai mise en commentaire pour voir un peu le résultat est ton scenario fonctionne quand même sans le NULL

**chlock62** · 04/12/2014, 15h02

Le fait d'utilisé la methode ci-dessous //tu dissocies la ligne du caddie.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
public function removeCartProduct(\Frontend\PanierBundle\Entity\CartProduct $cartProduct)
    {
        $this->cart_product->removeElement($cartProduct);
    }

car

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
$cart = $this->em->getRepository('MonBundle:Cart')->find(2);
//je récupére mon objet Cart_product
$cart_product = $this->em->getRepository('MonBundle:Cart')->find(3);
 
var_dump( $cart->getCartProduct()->getValues()); Premiere affichage de la collection cart_product: une ligne renvoyé Ok 
$cart->removeCartProduct($cart_product); //c'est ici que je veux appuyé les choses  
 
$this->em->persist($cart);
$this->em->flush();

//en faisant un deuxiéme affichage de la collection de cart_product, je vois bien que le cart_product a été supprimé Ok: 0 ligne renvoyé
var_dump( $cart->getCartProduct()->getValues()); me renvoie tableau vide donc la dissociation de la ligne au caddie a bien été faite

puis il fait ton scenario a mon avis
le NULL sur l'attribut cart_id sert dans le cas ou je souhaite gardé en base mais ne plus les associé comme tu me la dit auparavant ca c Ok
j’espère que tu m'as compris l’ami

methode remove dans une collection [2.x]

Symfony PHP

Discussions similaires

Partager

Partager