Les commentaires sont la pierre angulaire de tout processus de développement de produits réussi. Pour les développeurs de plugins WordPress, comprendre pourquoi les utilisateurs désactivent un plugin peut offrir des informations inestimables.

Alors que je développais un autre plugin génial pour WordPress à l’aide de Cloudflare, je voulais un système de retour si un utilisateur désactive mon plugin. J’ai commencé à chercher en ligne et les solutions trouvées n’étaient pas réalisables pour moi.

De nombreux créateurs de plugins WordPress s’appuient sur des enquêtes de désactivation intégrées ou sur des services tiers pour recueillir des commentaires. Cependant, ces méthodes comportent des limites et des problèmes:

  • Coûts: l’exécution de serveurs et la gestion de l’infrastructure pour la collecte de commentaires peuvent être coûteuses. Ainsi, les fournisseurs tiers facturent une somme considérable.
  • Latence: des mécanismes de rétroaction lents peuvent dissuader les utilisateurs de participer. Lorsqu’un utilisateur désactive un plugin, il ne s’attend pas à ce que la page se charge avant 10 secondes.
  • Problèmes d’intégration: de nombreux systèmes de feedback nécessitent une courbe d’apprentissage abrupte ou des processus d’intégration complexes, comme les SDK, etc.
  • Problèmes de confidentialité: la plupart des fournisseurs de services tiers collectent des données sensibles telles que des adresses e-mail, etc. Stocker les données sensibles de vos utilisateurs sur une plateforme qui peut ou non vendre ces données, être piratée ou pire; n’est tout simplement pas réalisable.

Alors, comment pouvez-vous recueillir ces commentaires de manière efficace, sécurisée et rentable? Entrez mon API basée sur Cloudflare Workers , KV et D1 .

J’ai décidé de créer ma propre API REST basée sur l’incroyable plateforme Cloudflare Workers, interconnectant efficacement mon espace membre déployé à l’aide de Pages avec l’API. Vous pouvez en savoir plus sur la façon dont j’ai créé mon espace membre ici .

Cela signifie que je peux restreindre l’utilisation de l’API uniquement aux membres estimés, tout en offrant la confidentialité et la sécurité des données stockées. L’API est extrêmement rapide dans le monde entier, sans temps d’arrêt, tout en maintenant un faible coût et une sécurité renforcée. Que peut-on vouloir de plus ? 😃

Et ce n’est qu’un début, car j’ai déjà préparé plusieurs points de terminaison pour de futurs services gratuits et payants pour les clients, développeurs et partenaires.

Commencer

Démarrer avec mon API est simple. Inscrivez-vous sur mon espace membre . Après l’inscription, visitez simplement votre profil . Si vous aviez déjà un compte, un ensemble de jetons API sera généré à la volée.

Vous trouverez sur cette page : ID de compte, Jeton public et Jeton privé :

  • L’ID de compte est utilisé pour identifier votre compte et stocker les informations en conséquence.
  • Le token Public est limité à certaines opérations, veuillez consulter les scopes.
  • Le token Privé n’est pas limité comme le token Public, et vous pouvez l’utiliser pour lire, écrire, supprimer des commentaires sur votre compte. Encore une fois, veuillez consulter les portées.

Remarque: Il existe une forte limitation de débit sur mon API pour éviter les abus. Si vous jouez trop, vous pourriez être restreint pendant au moins une heure ou plus.

Il n’y a aucun frais pour utiliser le point de terminaison de l’API de commentaires WordPress, c’est totalement GRATUIT, alors n’essayez pas d’en abuser ou je devrai bannir votre compte.

Intégrez l’API à votre plugin

L’intégration est super simple, il vous suffit de suivre ces étapes:

  1. Connectez-vous à admin_footer et injectez votre modal/formulaire de commentaires.
  2. Chargez votre CSS et JS en utilisant admin_enqueue_scripts; assurez-vous de les charger uniquement sur la page des plugins. Astuce: créez vos propres styles personnalisés, sinon vous briserez le style de la page des plugins ou même vous entrerez en conflit avec un autre modal de feedback du plugin.
  3. Créez une fonction d’administration AJAX pour traiter les commentaires; par exemple wp_ajax_your_plugin_deactivation_feedback. Remarque: n’utilisez toujours aucun pour sécuriser vos fonctions AJAX.

Lors de la collecte de commentaires, vous devez rassembler certaines informations et les envoyer à l’API en conséquence. Comme je suis très soucieux de ma vie privée, l’API ne stockera pas les adresses e-mail ou tout autre élément considéré comme confidentiel.

De plus, afin de respecter au mieux le RGPD, je propose les cinq emplacements proposés par D1 pour stocker les données collectées:

  • Ouest de l’Amérique du Nord
  • Est de l’Amérique du Nord
  • Europe de l’Ouest
  • L’Europe de l’Est
  • Asie-Pacifique

Dans cet esprit, je propose également une fonction d’assistance GEO qui renvoie la région pour votre hébergement. Cela signifie que vous pouvez stocker automatiquement les données dans la région fermée où votre WordPress est hébergé.

Un exemple de fonction pour obtenir la région:

 1private function get_region($account, $token)
 2{
 3	$api_url = "https://api.mecanik.dev/v1/developer/$account/geo-info";
 4
 5	$response = wp_remote_post($api_url, [
 6		'headers' => [
 7			'Authorization' => 'Bearer '.$token,
 8			'Content-Type' => 'application/json; charset=utf-8',
 9		],
10		'method' => 'GET',
11	]);
12
13	$response_body = wp_remote_retrieve_body($response);
14	$response_data = json_decode($response_body, true);
15	
16	return $response_data;
17}

This will return a JSON response like:

 1{
 2    "longitude": "8.68370",
 3    "latitude": "50.11690",
 4    "continent": "EU",
 5    "asn": 14061,
 6    "asOrganization": "Digital Ocean",
 7    "country": "DE",
 8    "isEUCountry": "1",
 9    "city": "Frankfurt am Main",
10    "region": "Hesse",
11    "timezone": "Europe/Berlin",
12    "postalCode": "60341",
13    "recommended-storage-region": "weur"
14}

Comme vous pouvez le voir dans cet exemple, le serveur réside dans la région Hesse, l’API recommande donc de stocker les données dans la région « weur ». Prenez cela avec un grain de sel; l’API ne peut pas garantir qu’elle renverra toujours la “recommandation” correcte.

Vous pouvez maintenant créer l’objet de retour et envoyer à l’API les éléments suivants: reason, comments, wp_plugin_name, wp_plugin_version, wp_site_url, wp_version, wp_locale, wp_multisite, php_version, db_type, db_version, server_type, server_version, date_created.

Un exemple de fonction pour envoyer les commentaires:

 1public function wp_ajax_your_plugin_deactivation_feedback()
 2{
 3	if (!wp_verify_nonce($_POST['nonce'], 'wp_ajax_your_plugin_deactivation_feedback_nonce')) {
 4		wp_send_json_error(esc_html__('Request is invalid. Please refresh the page and try again.', 'your-plugin-name'), 400, 0);
 5		exit();
 6	}
 7	
 8	$account = "....";
 9	$token = "....";
10	$api_url = "https://api.mecanik.dev/v1/developer/$account/wp-feedback";
11
12	$region = $this->get_region($account, $token);
13
14	$response = wp_remote_post($api_url, [
15		'headers' => [
16			'Authorization' => 'Bearer '.$token,
17			'Content-Type' => 'application/json; charset=utf-8',
18		],
19		'body' => json_encode([
20			'reason'             => sanitize_text_field($_POST['reason']),
21			'comments'           => sanitize_textarea_field($_POST['comments']),
22			'wp_plugin_name'     => $this->plugin_name,
23			'wp_plugin_version'  => $this->version,
24			'wp_site_url'        => get_bloginfo('url'),
25			'wp_version'         => $this->get_wp_version(),
26			'wp_locale'          => get_locale(),
27			'wp_multisite'       => is_multisite(),
28			'php_version'        => $this->get_php_version(),
29			'db_type'            => $this->get_db_type(),
30			'db_version'         => $this->get_db_version(),
31			'server_type'        => $this->get_server_type(),
32			'server_version'     => $this->get_server_version(),
33			'date_created'       => current_time('mysql'),
34			'region'             => $region['recommended-storage-region'],
35		]),
36		'method' => 'PUT',
37		'data_format' => 'body'
38	]);
39
40	$response_body = wp_remote_retrieve_body($response);
41	$response_data = json_decode($response_body);
42
43	if ($response_data && isset($response_data->success) && $response_data->success === false) {
44		$error_message = isset($response_data->errors[0]->message) ? esc_html($response_data->errors[0]->message) : 'Unknown error';
45		wp_send_json_error($error_message, 400);
46		exit();
47	}
48	else if ($response_data && isset($response_data->success) && $response_data->success === true && isset($response_data->error)) {
49		wp_send_json_error($response_data->error, 400);
50		exit();
51	}
52	
53	wp_send_json_success($response_data, 200, 0);
54}

Une réponse de retour enregistrée avec succès sera renvoyée comme: Commentaires enregistrés dans la région <region_name>.

Dans l’exemple de fonction ci-dessus, vous pouvez voir que nous rassemblons php_version, db_type, db_version, etc. Pour votre commodité, je vais vous fournir quelques exemples de fonctions pour celles-ci:

 1private function get_wp_version() {
 2	global $wp_version;
 3	return $wp_version;
 4}
 5
 6private function get_php_version() {
 7	return PHP_VERSION;
 8}
 9
10private function get_db_type() {
11	global $wpdb;
12
13	$query = "SELECT TABLE_SCHEMA FROM information_schema.TABLES WHERE TABLE_NAME = 'wp_options'";
14	$result = $wpdb->get_row($query);
15
16	if ($result && isset($result->TABLE_SCHEMA)) {
17		$table_schema = $result->TABLE_SCHEMA;
18
19		if (strpos($table_schema, 'mysql') !== false) {
20			return 'MySQL';
21		} elseif (strpos($table_schema, 'pgsql') !== false) {
22			return 'PostgreSQL';
23		} elseif (strpos($table_schema, 'sqlite') !== false) {
24			return 'SQLite';
25		}
26	}
27
28	return 'Unknown';
29}
30
31private function get_db_version() {
32	global $wpdb;
33	return $wpdb->db_version();
34}
35
36private function get_server_type() {
37	if (isset($_SERVER['SERVER_SOFTWARE'])) {
38		return explode(' ', $_SERVER['SERVER_SOFTWARE'])[0];
39	}
40	return 'Unknown';
41}
42
43private function get_server_version() {
44	$uname = php_uname('s');
45
46	$serverTypes = [
47		'Apache' => 'Apache',
48		'Nginx' => 'Nginx',
49		'LiteSpeed' => 'LiteSpeed'
50	];
51
52	if (isset($serverTypes[$uname])) {
53		return $serverTypes[$uname];
54	}
55
56	return '0.0.0';
57}

Vous devriez maintenant avoir tout ce dont vous avez besoin pour recueillir vos retours de désactivation du plugin WordPress. Modifiez si nécessaire pour répondre à vos besoins.

Commencez à collecter des commentaires sur la désactivation

Si vous avez suivi les étapes ci-dessus, lorsqu’un utilisateur tente de désactiver votre plugin, le modal de retour devrait apparaître:

Commentaires sur la désactivation du plugin WordPress

L’utilisateur peut saisir les raisons de la désactivation de votre plugin. Vous pouvez récupérer tous vos retours recueillis depuis l’API à tout moment.

Documentation API

Point de terminaison de base:

https://api.mecanik.dev/v1/developer

Point de terminaison des commentaires WordPress:

https://api.mecanik.dev/v1/developer/{account_id}/wp-feedback

Récupérer des Commentaires

  • Méthode: GET
  • URL: https://api.mecanik.dev/v1/developer/{account_id}/wp-feedback?region=[region]
  • Paramètres d'URL:
    • region (Obligatoire): Le code de la région où le commentaire est stocké. Peut être `wnam`, `enam`, `weur`, `eeur` ou `apac`.
  • Portée: read:wp_feedback
  • En-têtes:
    • Authorization: Jeton Bearer pour l'accès.
  • Réponse:
    • 200 OK avec les données du commentaire si réussi.
    • 400 Mauvaise Requête si la région est invalide.
    • 403 Interdit si le jeton n'est pas autorisé.
    • 404 Non Trouvé si le jeton n'existe pas.
    • 406 Non Acceptable si une région invalide est fournie.

Enregistrer un Commentaire

  • Méthode: PUT
  • URL: https://api.mecanik.dev/v1/developer/{account_id}/wp-feedback
  • Portée: write:wp_feedback
  • En-têtes:
    • Authorization: Jeton Bearer pour l'accès.
    • Type de Contenu: application/json
  • Corps:
    • Objet JSON contenant:
      • reason (Obligatoire): Raison de la désactivation de l'utilisateur. Format autorisé : `string`.
      • comments (Obligatoire): Commentaires de désactivation de l'utilisateur. Format autorisé : `string`.
      • wp_plugin_name (Obligatoire): Nom actuel du plugin WordPress. Format autorisé : `string`.
      • wp_plugin_version (Obligatoire) : Version actuelle du plugin WordPress. Format autorisé : `0.0.0.0`.
      • wp_site_url (Obligatoire): URL actuelle de WordPress. Format autorisé : `string`.
      • wp_version (Obligatoire): Version actuelle de WordPress. Format autorisé : `0.0.0.0`.
      • wp_locale (Obligatoire): Locale actuelle de WordPress. Format autorisé : `string`.
      • wp_multisite (Obligatoire): Si l'installation actuelle de WordPress est multisite. Format autorisé : `boolean`.
      • php_version (Obligatoire): Version actuelle de PHP. Format autorisé : `0.0.0.0`.
      • db_type (Obligatoire): Type actuel du serveur de base de données. Format autorisé : `string`.
      • db_version (Obligatoire): Version actuelle du serveur de base de données. Format autorisé : `0.0.0.0`.
      • server_type (Obligatoire): Type actuel du serveur web. Format autorisé : `string`.
      • server_version (Obligatoire): Version actuelle du serveur web. Format autorisé : `0.0.0.0`.
      • date_created (Obligatoire): Date/heure de création du commentaire. Format autorisé : `AAAA-MM-JJ HH:MM:SS`.
      • region (Obligatoire): Le code de la région où le commentaire est stocké. Peut être `wnam`, `enam`, `weur`, `eeur` ou `apac`.
  • Réponse:
    • 200 OK si le commentaire est enregistré avec succès.
    • 400 Mauvaise Requête si l'un des paramètres fournis est invalide.
    • 403 Interdit si le jeton n'est pas autorisé ou révoqué/interdit.
    • 404 Non Trouvé si le jeton n'existe pas.
    • 406 Non Acceptable si une région invalide est fournie.
    • 500 Erreur Interne du Serveur s'il y a une erreur lors de l'enregistrement du commentaire.

Supprimer des Commentaires

  • Méthode: POST
  • URL: https://api.mecanik.dev/v1/developer/{account_id}/wp-feedback
  • Portée: delete:wp_feedback
  • En-têtes:
    • Authorization: Jeton Bearer pour l'accès.
    • Type de Contenu: application/json
  • Corps:
    • Objet JSON contenant:
      • feedback_ids (Obligatoire): ID du commentaire à supprimer. Format autorisé: `[1, 2, 3]`.
      • region (Obligatoire): Le code de la région où le commentaire est stocké. Peut être `wnam`, `enam`, `weur`, `eeur` ou `apac`.
  • Réponse:
    • 200 OK si le commentaire est supprimé avec succès.
    • 400 Mauvaise Requête si l'ID du commentaire fourni est invalide.
    • 403 Interdit si le jeton n'est pas autorisé ou révoqué/interdit.
    • 404 Non Trouvé si le jeton n'existe pas.
    • 500 Erreur Interne du Serveur s'il y a une erreur lors de la suppression du commentaire.

Conclusion

Avoir un tel système de feedback fera une énorme différence dans le développement de votre plugin. J’espère que cet article vous a été utile et que vous pourrez améliorer votre plugin WordPress en utilisant mon API.

Je pourrais introduire un retour d’activation à l’avenir, mais je suis très sceptique à ce sujet car les utilisateurs ne peuvent pas “s’inscrire” ou “se désinscrire”. Donc pour l’instant, nous n’aurons que des retours de désactivation.

Si vous avez des commentaires ou des suggestions, n’hésitez pas à utiliser le système de commentaires ci-dessous.