Skip to content
The Chat Archive
gpt-4-0314· OpenAI WildChat-4.8M (AI2)

Salut, j'ai un formulaire géré avec react-hook-form, et j'aimerais lancer une fonction…

  1. User

    Salut, j'ai un formulaire géré avec react-hook-form, et j'aimerais lancer une fonction seulement si un champs a une valeure, sinon la function n'est pas lancée. Mon code ne fonctionne pas, tu sais pourquoi ? ``` let refmodel = watch(["reference_model"]); useEffect(() => { if (!refmodel) { handleSelectChange(); } else { return } }, [ handleSelectChange, refmodel]);

  2. Assistant

    Il semble que le problème peut être lié à la variable refmodel, il faut vérifier sa valeur pour mentionner si votre fonction doit être exécutée.

    La valeur de refmodel nouvellement surveillée est renvoyée dans un tableau. Cependant, vous ne vous référez pas à l'index 0 du tableau.

    Essayez de modifier votre code de cette manière:

      let refmodel = watch(["reference_model"]);
      useEffect(() => {
        if (!refmodel[0]) {
          handleSelectChange();
        } else {
          return
        }
      }, [handleSelectChange, refmodel]);
    

    Dans ce code, refmodel[0] sera vérifié au lieu de refmodel. Si refmodel[0] n'a pas de valeur, handleSelectChange() sera exécuté, sinon rien ne sera fait.

  3. User

    salut, j'ai un formulaire géré via react-hook-form et react-select. sait-tu pourquoi le select montre bien les options mais je ne peux pas en choisir, je clique sur une option la valeure choisie n'est pas prise en compte const [selectedOption, setSelectedOption] = useState(""); <Controller name="client_first_name_select" control={control} render={({ field }) => ( <Select className="clientName__wrapper__form__inputs__fields" options={options} onChange={() => { setSelectedOption(selectedOption); addSelectedClient(); field.onChange(selectedOption); // Mettre à jour la valeur du champ dans React Hook Form }} onBlur={field.onBlur} value={field.value} /> )} />

  4. Assistant

    Le problème semble provenir de la façon dont vous gérez la fonction onChange pour le composant Select. Dans la fonction onChange, vous mettez à jour l'état selectedOption avec la valeur actuelle de selectedOption, ce qui ne modifiera pas la valeur.

    Au lieu de cela, vous devez capturer l'option sélectionnée à partir de l'événement onChange. Essayez de le changer comme suit:

    <Controller
      name="client_first_name_select"
      control={control}
      render={({ field }) => (
        <Select
          className="clientName__wrapper__form__inputs__fields"
          options={options}
          onChange={(selectedOption) => {
            setSelectedOption(selectedOption);
            addSelectedClient();
            field.onChange(selectedOption); // Mettre à jour la valeur du champ dans React Hook Form
          }}
          onBlur={field.onBlur}
          value={field.value}
        />
      )}
    />
    

    Ici, je passe selectedOption en tant qu'argument dans la fonction onChange et je l'utilise directement pour mettre à jour l'état et appeler les fonctions. Cela devrait résoudre le problème de mise à jour de la valeur sélectionnée.

  5. User

    Merci, ce formulaire est lié à woocmmerce via Rest APi. dans les commandes Woocommerce il y a des champs ACF. Comment ajouter les valeurs des chamsp react-select et react-hook-form dans les champs ACF de la commande par exemple le champs order_watch_reference. Actuellement ce champs est sauvgardé dans les post meta de la commande via rest api

  6. Assistant

    Pour ajouter des valeurs dans les champs ACF de votre commande WooCommerce, vous devez d'abord vous assurer que le champ ACF existe et est configuré pour être inclus dans l'API REST de WooCommerce.

    Une fois que vous avez confirmé que votre champ ACF est correctement configuré, vous pouvez ajouter les valeurs à partir de votre formulaire en modifiant votre requête API pour inclure le champ ACF qui doit être mis à jour. Cela dépend de la méthode que vous utilisez pour soumettre votre formulaire et interagir avec l'API WooCommerce, mais cela pourrait ressembler à ce qui suit :

    // Exemple avec fetch et axios
    const handleSubmit = async (data) => {
      try {
        // Soumettre le formulaire avec la valeur du champ client_first_name_select ou order_watch_reference
        const response = await fetch("https://example.com/wp-json/wc/v3/orders", {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            "Authorization": "Basic " + btoa("CONSUMER_KEY:CONSUMER_SECRET"), // Utilisez vos clés d'API WooCommerce ici
          },
          body: JSON.stringify({
            ...data, // Vos autres données de formulaire
    
            // Ajoutez cet objet pour mettre à jour les champs ACF par order_watch_reference
            acf_fields: {
              order_watch_reference: data.client_first_name_select.value
            },
    
          }),
        });
    
        if (response.ok) {
          const jsonResponse = await response.json();
          console.log("Formulaire soumis avec succès !", jsonResponse);
        } else {
          console.log("Erreur lors de l'envoi du formulaire :", response.statusText);
        }
      } catch (error) {
        console.error("Erreur lors de la soumission du formulaire :", error);
      }
    };
    

    Cet exemple utilise fetch() et dépendra du paramètre de l'objet data qui est passé à la fonction handleSubmit. Si vous utilisez axios, vous pouvez adapter cet exemple en conséquence. La clé ici est d'inclure un objet acf_fields dans la demande, où la clé est le nom du champ ACF (par exemple order_watch_reference) et la valeur est la valeur du champ de votre formulaire.

    Assurez-vous d'adapter cet exemple pour l'utiliser avec react-hook-form. Vous pouvez appeler cette fonction handleSubmit dans onSubmit de votre formulaire.

    const { handleSubmit } = useForm();
    
    return (
      <form onSubmit={handleSubmit(saveDataToWooCommerce)}>
        {/* le reste de votre formulaire */}
      </form>
    );
    

    N'oubliez pas de remplacer les clés d'API WooCommerce par vos propres valeurs.

    Une fois que vous avez soumis avec succès votre formulaire, la valeur du champ ACF devrait être ajoutée à l'objet de la commande dans WooCommerce.

  7. User

    comment tu adapterais cette fonction pour ajouter ce tableau aussi dans acf_fields. actuellement le tableau est stocké dans la commande, dont une copei est stockée dans le local storage et l'autre copie est envoyé à Woocommerce pour mettre à jour la command avec les post_meta ``` const handleSelectChange = async () => { const fieldValues = getValues(); const commande = JSON.parse(localStorage.getItem("orderData"));

    if (fieldValues.refModelSelect) {
      const postMeta = [
        { meta_key: "refModel", meta_value: fieldValues.reference_model },
        {
          meta_key: "refModel",
          meta_value: fieldValues.refModelSelect.label,
        },
        {
          meta_key: "order_watch_reference",
          meta_value: fieldValues.refModelSelect.value,
        },
      ];
    
      try {
        const reponses = await Promise.all(
          postMeta.map(async (meta) => {
            const cle = Object.keys(meta)[0];
            const valeur = Object.values(meta)[1];
            const meta_data = {
              meta_data: [
                {
                  key: cle,
                  value: valeur,
                },
              ],
            };
            console.log(meta_data);
            await new Promise((resolve) => setTimeout(resolve, 2000));
    
            const reponse = await jrURL.post(
              `/wc/v3/orders/${commande.id}`,
              meta_data
            );
            return reponse.data;
          })
        );
        const valeur = postMeta;
        commande.meta_data.refModel = valeur;
        console.log(commande);
    
        localStorage.setItem("orderData", JSON.stringify(commande));
    
        console.log(reponses);
      } catch (erreur) {
        console.error(erreur);
      }
    }
    

    };```

  8. Assistant

    Il vous suffit d'ajouter les valeurs des post_meta dans le champ ACF approprié. Supposons que vous vouliez enregistrer toutes les informations dans un champ ACF nommé order_metadata sous forme de JSON.

    1. Mettez à jour votre fonction handleSubmit pour inclure order_metadata dans l'objet acf_fields.
    const saveDataToWooCommerce = async (data) => {
      try {
        // Soumettre le formulaire avec la valeur du champ client_first_name_select ou order_watch_reference
    
        // Récupérer la commande du localStorage
        const orderData = JSON.parse(localStorage.getItem('orderData'));
    
        const response = await fetch("https://example.com/wp-json/wc/v3/orders", {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            "Authorization": "Basic " + btoa("CONSUMER_KEY:CONSUMER_SECRET"), // Utilisez vos clés d'API WooCommerce
          },
          body: JSON.stringify({
            ...data, // Vos autres données de formulaire
    
            // Ajoutez cet objet pour mettre à jour les champs ACF par order_watch_reference et order_metadata
            acf_fields: {
              order_watch_reference: data.client_first_name_select.value,
              order_metadata: JSON.stringify(orderData.meta_data.refModel),
            },
    
          }),
        });
    
        if (response.ok) {
          const jsonResponse = await response.json();
          console.log("Formulaire soumis avec succès !", jsonResponse);
        } else {
          console.log("Erreur lors de l'envoi du formulaire :", response.statusText);
        }
      } catch (error) {
        console.error("Erreur lors de la soumission du formulaire :", error);
      }
    };
    
    1. Mettez à jour la fonction handleSelectChange pour stocker les données de post_meta directement dans localStorage comme orderData.meta_data.refModel. Vous pouvez supprimer les appels API non nécessaires dans handleSelectChange.
    const handleSelectChange = async () => {
      const fieldValues = getValues();
      const orderData = JSON.parse(localStorage.getItem("orderData"));
    
      if (fieldValues.refModelSelect) {
        const postMeta = [
          { meta_key: "refModel", meta_value: fieldValues.reference_model },
          {
            meta_key: "refModel",
            meta_value: fieldValues.refModelSelect.label,
          },
          {
            meta_key: "order_watch_reference",
            meta_value: fieldValues.refModelSelect.value,
          },
        ];
    
        // Mettez à jour les informations de post_meta dans localStorage
        orderData.meta_data.refModel = postMeta;
        localStorage.setItem("orderData", JSON.stringify(orderData));
        console.log(orderData);
      }
    };
    

    Maintenant, lorsque vous soumettez le formulaire avec la fonction saveDataToWooCommerce, les champs ACF associés à la commande sont mis à jour avec les informations correctes. Assurez-vous d'adapter ces exemples pour les utiliser avec react-hook-form.

  9. User

    Je ne comprends pas, peut-tu me montrer comment mettre à jour une commande existante pour que les champs ACF de la commande soit complété par les valeurs des mes inputs

  10. Assistant

    Pour mettre à jour une commande existante et mettre à jour les champs ACF, vous devez d'abord vous assurer que les champs ACF sont configurés correctement et exposés via l'API REST de WooCommerce. Ensuite, vous pouvez envoyer une requête POST ou PUT pour mettre à jour la commande existante avec les données des champs de formulaire. Dans cet exemple, j'explique comment faire une requête PUT pour mettre à jour la commande avec les champs ACF.

    Voici comment procéder pour soumettre les données du formulaire et mettre à jour les champs ACF de la commande avec les valeurs des entrées:

    1. Configurez votre formulaire avec react-hook-form et react-select. Assurez-vous d'utiliser la fonction register pour enregistrer les entrées de formulaire que vous souhaitez collecter. Vous pouvez également utiliser le contrôleur pour react-select comme vous l'avez fait précédemment.

    2. Créez une fonction pour gérer la soumission du formulaire. Cette fonction doit extraire les valeurs des champs, puis envoyer une requête API pour mettre à jour la commande avec les données ACF.

    // Cette fonction sera appelée lors de la soumission du formulaire
    const onSubmit = async (formData) => {
      // Extraire les valeurs des champs ici
      const order_watch_reference = formData.client_first_name_select.value;
    
      // Vous pouvez ajouter d'autres valeurs de champ ici
      // par exemple : const another_acf_field = formData.another_field;
    
      // Construire l'objet ACF Fields
      const acf_fields = {
        order_watch_reference,
        // ajoutez d'autres champs ACF ici si nécessaire
        // another_acf_field,
      };
    
      // Envoi d'une requête PUT pour mettre à jour la commande
      try {
        const orderId = 123; // Remplacez 123 par l'ID de la commande que vous souhaitez mettre à jour
    
        const response = await fetch(`https://example.com/wp-json/wc/v3/orders/${orderId}`, {
          method: "PUT",
          headers: {
            "Content-Type": "application/json",
            "Authorization": "Basic " + btoa("CONSUMER_KEY:CONSUMER_SECRET"), // Utilisez vos clés d'API WooCommerce
          },
          body: JSON.stringify({
            // Ajoutez cet objet pour mettre à jour les champs ACF
            acf_fields,
          }),
        });
    
        if (response.ok) {
          const jsonResponse = await response.json();
          console.log("Commande mise à jour avec succès !", jsonResponse);
        } else {
          console.log("Erreur lors de la mise à jour de la commande :", response.statusText);
        }
      } catch (error) {
        console.error("Erreur lors de la mise à jour de la commande :", error);
      }
    };
    
    1. Utilisez la fonction onSubmit de react-hook-form pour appeler votre fonction lorsque le formulaire est soumis.
    const { register, handleSubmit } = useForm();
    
    return (
      <form onSubmit={handleSubmit(onSubmit)}>
        {/* le reste de votre formulaire */}
      </form>
    );
    

    Cet exemple utilise fetch() pour envoyer la requête API, mais vous pouvez également utiliser axios ou une autre bibliothèque de requête HTTP si vous préférez. L'essentiel est que vous devrez envoyer une requête PUT pour mettre à jour la commande avec les données du formulaire, y compris les champs ACF.

    N'oubliez pas de remplacer les clés d'API WooCommerce par vos propres valeurs, ainsi que l'URL de base de votre site WordPress.