Créer un commerce électronique SaaS dans WordPress en utilisant un téléchargement numérique simple

Le te de l’application concerne WordPress et je vais en discuter dans un autre article.
Je veux parler d’une façon d’intégrer les boucles EDD et EDD aux applications externes. Ce dont nous avons besoin, c’est d’envoyer une demande d’api à l’application chaque fois qu’un abonnement est créé, mis à jour ou créé. En outre, cette logique doit être limitée à des abonnements spécifiques, car nous avons de nombreux autres types de produits basés sur les abonnements. Cette partie de cet article est basée sur le plug – in que j’ai écrit pour gérer l’interaction des EDD fonctionnant sur les formulaires Caldera. Com et Caldera forms pro. Bien qu’il s’agisse d’un plug – in spécifique au site et qu’il ne puisse peut – être pas être réutilisé tel quel, j’espère que d’autres peuvent apprendre en lisant et en copiant.
La séparation de la logique de la récupération EDD de l’API plug – in fournit tous les crochets nécessaires pour qu’elle fonctionne. Mais avant de me lier à ces événements, j’ai créé la logique nécessaire dans les classes complètement découplées de ces crochets. Cela rend mon code plus facile à tester, ce qui signifie également qu’il est plus facile à utiliser lorsque j’ai besoin d’autres façons de traiter les abonnements. La première étape consiste à créer une classe d’abonnement pour gérer toute la logique de cet abonnement. Dans un récent article de Torque, j’a i discuté des modèles décoratifs comme alternative à l’extension de classe. Parce que je pense que cet objet d’abonnement a une responsabilité fondamentalement différente de la classe d’abonnement EDD \ U, j’a i choisi de modifier la classe d’abonnement EDD \ U au lieu de l’étendre.
Je dis \
C’est très simple. L’abonnement EDD _ a une méthode Get Status (). Mais ce que je veux vraiment savoir, c’est si cet état représente un abonnement actif. Abonnement = $abonnement;
}
\/ * *
Renvoie booléen
* \/
Fonction commune statusactive (): bool
{Y}
Retour en _ array ($this – > Subscription – > get Status () [retour en array ($this – > Subscription – > get Status ()]
« activité»,
\
];
}
Cette méthode peut être utilisée lors de diverses opérations qui se produisent lorsque l’abonnement change. Mais avant de vérifier, je pense qu’il serait utile de créer une usine pour ces articles, qui pourrait déterminer si l’abonnement EDD est utilisé pour les produits SaaS. Si vous n’êtes pas familier avec ce modèle, j’ai discuté du modèle d’usine dans l’article précédent.
Ce code suppose qu’une variable d’environnement fournit un ID de produit pour le produit d’abonnement. Si la configuration WordPress n’utilise pas de variables d’environnement, vous pouvez utiliser des constantes. ID & (int) $abonnement – > produit _ id = = (int) $ENV [‘SaaS Product id’];
}
} cela nous donne un moyen d’obtenir des articles d’abonnement en vérifiant si les articles d’abonnement sont appropriés pour le bon produit.
Comme je l’ai déjà dit, il est important pour moi de garder toute la logique découplée de l’API plug – in, mais cela ne signifie pas qu’elle n’a pas à être associée aux actions activées par EDD lors de la création, de la mise à jour, de l’abonnement ou du renouvellement. J’a i utilisé une classe Hooks pour gérer l’interaction avec l’API plug – in. Dans chaque rappel, si la classe d’abonnement est le bon produit, appelez la méthode Factory pour l’obtenir. Comme cette méthode renvoie NULL, une condition simple empêche l’exécution de code supplémentaire lorsque ces crochets ne sont pas nécessaires.
Voici le schéma de cette classe: Statoactive () {
Appeler la création d’api distante
}
}
\/ * *
Le contenu de l’application peut être annulé ou créé après la mise à jour de l’abonnement
* *
Utiliser \
Mise à jour _ abonnement \
* *
Paramètre $id
* \/
Abonnement à la fonction publique _ mis à jour ($ID)
$abonnement = usine:: abonnement ($ID);
Si ($abonnement & $abonnement – > actif ()) {
Appeler l’API distante pour la mise à jour
} ElseIf ($Subscription &! $Subscription – > Activity ()}
Appeler l’API distante pour annuler
}
}
\/ * *
* suivez notre logique lors de la désabonnement
* *
Utiliser EDD _ Subscription cancelled
* *
Param int $ID Subscription id
* \/
Abonnement à la fonction publique _ annulé ($ID)
$abonnement = usine:: abonnement ($ID);
Si ($abonnement)
Appeler l’API distante pour annuler
}
}
} ce que vous faites dans ces conditions dépend de la façon dont votre application fonctionne. Si vous voulez voir comment je gère mon application, vous pouvez lire le code source ici.
Vendre l’accès aux paramètres de l’api de repos WordPress de nombreux produits SaaS vendent l’accès à l’api. Il peut s’agir de l’ensemble du produit, et l’API Google Maps en est un exemple: ils limitent leur API et vous pouvez acheter d’autres demandes. Dans d’autres cas, les produits SaaS incluent l’interface, qui peut être utilisée un nombre limité de fois par mois, ce qui nécessite techniquement un paramètre API à débit limité. Même si le produit SaaS n’est pas basé sur une limite de vitesse, par exemple, il s’agit d’un abonnement mensuel ou annuel, si vous utilisez l’API rest, vous devez toujours contrôler l’accès par abonnement.
Dans cette partie de cet article, je vais discuter d’une approche basée sur l’abonnement pour contrôler l’accès à l’api WordPress rest et fournir des réponses significatives aux erreurs qui peuvent être utilisées dans l’application. En fait, j’a i créé un plug – in assez complet qui utilise l’ajout de paiement périodique d’EDD pour tout faire. Cependant, il n’est pas très lié à Edd et peut être facilement exécuté par le plug – in membre ou woocommerce. La forme originale de mon plan cratère
Propriété du routage à partir de
Si (0! = = strpos ($this – > route, \
$this – > route = \
}
Vérifier si le chemin est un chemin
Si (0 = = strpos ($request – > get route (), $this – > route) {
Supposons qu’il y ait trop de demandes logiques pour renvoyer une erreur wp \ u en utilisant le Code 429
$check = sth ();
Si (IS _ WP Error ($check)
Retourner $this – > Generate _ Error Response ($check);
Autres {
Autoriser le retour intact
Renvoie $service;
}
Autres {
\/ \/ ce n’est pas notre cours, il est revenu, il n’a pas changé
Renvoie $service;
}
}
\/ * *
Générer une réponse d’erreur
* *
Paramètre \ wp _ Error $Error
Paramètre int $status
* *
Retour à la réponse
* \/
La fonction protégée génère une réponse d’erreur (\ wp _ Error $error, $status = 429) {
Retour à la nouvelle réponse
[‘message’ = > $Error – > get _ error message ($status)]],
$status
);
}
Ça ne sert à rien, mais j’aimerais en faire un point de départ pour comprendre ce concept. Votre mise en oeuvre des restrictions tarifaires ou de la logique des comptes peut également être complètement différente, mais elle peut être le point de départ d’autres approches. Notez que ce code appelle une fonction appelée \
}
\/ * *
Obtenez tous les événements ou abonnements gratuits
* *
Paramètre $user _ id
* *
Retourner le tableau
* \/
Fonctions statiques publiques get _ user subscriptions ($user id) {
Retourner (nouveau \ \ EDD \ \ recurrental \ \ u Subscriber ($user \ \ ID, True))
Obtenir l’abonnement ($u ENV [‘SaaS _ Product id’]]
« activité»,
\
));
}
Commençons par une classe pour gérer notre logique. Un problème complexe que j’a i découvert est que les abonnements EDD \ u utilisent des tables personnalisées sans méta – tables. J’ai trouvé des solutions. Dans le plug – in API Speed limit, j’a i séparé la limite de vitesse de l’abonnement et j’ai compté l’utilisation dans un tableau personnalisé. Dans cet exemple de code, j’utiliserai un type de message personnalisé caché appelé « \ u limit _ Tracker » qui contient deux métachamps: « \ u Subscription ID » et « \ u uses ». Abonnement = usine:: get _ user Subscription ($user id);
}
\/ * *
Vérifier si la demande doit être acceptée
* *
Retour bool | \ \ wp _ Error
* \/
Fonctions publiques autorisées () {
Si (NULL ($this – > Subscription) {
$this – > Error Code = 403;
Renvoie une nouvelle erreur \ \ wp \ ($this – > Error \ \ Code, \ (‘no Subscription found’, ‘text Domain’);
}
If (True = = $this – > check _ use ($this – > Subscription [0]) {
Renvoie True;
Autres {
$this – > Error Code = 429;
Renvoie une nouvelle erreur \ \ wp \ ($this – > Error \ \ Code, \ (‘Speed limit exceed’, ‘text Domain’);
}
}
\/ * *
Retourner int | null
* \/
Fonction publique get _ Error Code () {
Renvoie $this – > Error _ Code;
}
\/ * *
Paramètre int $Subscription id
* \/
Fonction protégée check _ use ($Subscription ID) {
$WP _ Query = new WP Query ([]
‘post _ type’ = > ‘limit Tracker’,
« Meta query» = >
‘key’ = > ‘_ Subscription id’,
« valeur» = > $ID d’abonnement,
« comparer» = > ‘=
[1]
));
Si (NULL ($WP _ Query – > posts [0]) {
$id = wp \ u insert \ u post
‘post _ type’ = > ‘limit Tracker’,
« contenu de la publication» = [1jeemaa1] »
];
Mettre à jour _ post Meta ($ID, $Subscription ID, $Subscription ID);
$utilisation = 0;
Autres {
$id = $wp \ u Query – > post [0] – > ID;
$uses = get _ post Meta ($ID, \
}
Si ($utilise > $ceci – > utilisation maximale) {
Renvoie False;
Autres {
Mettre à jour _ post Meta ($ID, $USA, $USA + 1);
Renvoie True;
}
}
Ce cours
, je l’utiliserai dans la classe route et vérifierai plus tard le type de post caché pour les statistiques d’utilisation. Comme vous pouvez le voir dans la méthode check _ use (), chaque fois que vous vérifiez, une autre utilisation est calculée et comparée à l’utilisation maximale autorisée. Vous devrez peut – être étendre cette logique pour une utilisation ou une récupération mensuelle. Mon but est de vous donner un point de départ et d’expliquer comment ce type de cours peut être mené. Avec cela, nous pouvons utiliser cette logique pour compléter la classe de chemin que nous avons lancée précédemment. Cette classe est prête à formater l’erreur wp \ u en réponse au repos ou à permettre le passage de la demande. Par conséquent, il suffit d’appeler cette logique dans la méthode de vérification qui se connecte au repos _ pre Dispatch pour arrêter les requêtes non autorisées. Chemin = $chemin;
Ajouter un filtre (‘rest _ pre Dispatch’, [$this, ‘check’, 10, 3);
}
\/ * *
* avant que wordpress ne réponde à la demande, vérifiez si un blocage est nécessaire et, si nécessaire, bloquez
* *
@ Param bool $Service if requested
Param \ wp _ rest Server $Server Server instance.
@ Param \ wp _ rest request $request used to Generate a response.
* *
Renvoie booléen
* \/
Vérification de la fonction publique ($Server, $Server, $Request) {
Assurez – vous que la propriété route est
Si (0! = = strpos ($this – > route, \
$this – > route = \
}
Vérifier si le chemin est un chemin
Si (0 = = strpos ($request – > get route (), $this – > route) {
Supposons qu’il y ait trop de demandes logiques pour renvoyer une erreur wp \ u en utilisant le Code 429
$Checker = nouveau limiteur (get _ current user id ();
$allow = $Checker – > allow ();
Si (IS _ WP Error ($allow) {
Retourner $this – > Generate _ Error Response ($allowed, $Checker – > get Error Code ();
Autres {
Autoriser le retour intact
Retourner $Serv
E \/
}
Autres {
\/ \/ ce n’est pas notre cours, il est revenu, il n’a pas changé
Renvoie $service;
}
}
\/ * *
Générer une réponse d’erreur
* *
Paramètre \ wp _ Error $Error
Paramètre int $status
* *
Retour à la réponse
* \/
La fonction protégée génère une réponse d’erreur (\ wp _ Error $error, $status = 429) {
Retour à la nouvelle réponse
[‘message’ = > $Error – > get _ error message ($status)]],
$status
);
}
} WAAS – WordPress en tant que SaaS j’espère que cet article vous donne beaucoup d’idées et le début du Code nécessaire pour créer un SaaS basé sur WordPress. Que vous utilisiez WordPress uniquement pour le commerce électronique ou pour l’ensemble de l’application, WordPress est un excellent outil pour ces projets, car peu importe combien vous choisissez d’utiliser.