update docs. 9.x

webmasternexusconsultores · May 2, 2022 · d519758 · d519758
1 parent 52ef08e
commit d519758
Show file tree

Hide file tree

Showing 8 changed files with 249 additions and 41 deletions.
diff --git a/docs/basic-usage.md b/docs/basic-usage.md
@@ -40,19 +40,52 @@ class User extends Model implements Customer
 }
 ```
 
-Add the `HasWallet` trait and `Product` interface to `Item` model.
+Add the `HasWallet` trait and interface to `Item` model.
+
+Starting from version 9.x there are two product interfaces:
+- For an unlimited number of products (`ProductLimitedInterface`);
+- For a limited number of products (`ProductInterface`);
+
+An example with an unlimited number of products:
 ```php
 use Bavix\Wallet\Traits\HasWallet;
-use Bavix\Wallet\Interfaces\Product;
 use Bavix\Wallet\Interfaces\Customer;
+use Bavix\Wallet\Interfaces\ProductInterface;
 
-class Item extends Model implements Product
+class Item extends Model implements ProductInterface
+{
+    use HasWallet;
+
+    public function getAmountProduct(Customer $customer)
+    {
+        return 100;
+    }
+
+    public function getMetaProduct(): ?array
+    {
+        return [
+            'title' => $this->title, 
+            'description' => 'Purchase of Product #' . $this->id,
+        ];
+    }
+}
+```
+
+Example with a limited number of products:
+```php
+use Bavix\Wallet\Traits\HasWallet;
+use Bavix\Wallet\Interfaces\Customer;
+use Bavix\Wallet\Interfaces\ProductLimitedInterface;
+
+class Item extends Model implements ProductLimitedInterface
 {
     use HasWallet;
 
     public function canBuy(Customer $customer, int $quantity = 1, bool $force = false): bool
     {
         /**
+         * This is where you implement the constraint logic. 
+         * 
          * If the service can be purchased once, then
          *  return !$customer->paid($this);
          */
@@ -74,6 +107,10 @@ class Item extends Model implements Product
 }
 ```
 
+I do not recommend using the limited interface when working with a shopping cart.
+If you are working with a shopping cart, then you should override the `PurchaseServiceInterface` interface.
+With it, you can check the availability of all products with one request, there will be no N-queries in the database.
+
 Proceed to purchase.
 
 ```php

diff --git a/docs/cart.md b/docs/cart.md
@@ -16,41 +16,77 @@ class User extends Model implements Customer
 
 ## Item Model
 
-Add the `HasWallet` trait and `Product` interface to Item model.
+Add the `HasWallet` trait and interface to `Item` model.
 
+Starting from version 9.x there are two product interfaces:
+- For an unlimited number of products (`ProductLimitedInterface`);
+- For a limited number of products (`ProductInterface`);
+
+An example with an unlimited number of products:
 ```php
 use Bavix\Wallet\Traits\HasWallet;
-use Bavix\Wallet\Interfaces\Product;
 use Bavix\Wallet\Interfaces\Customer;
+use Bavix\Wallet\Interfaces\ProductInterface;
 
-class Item extends Model implements Product
+class Item extends Model implements ProductInterface
+{
+    use HasWallet;
+
+    public function getAmountProduct(Customer $customer)
+    {
+        return 100;
+    }
+
+    public function getMetaProduct(): ?array
+    {
+        return [
+            'title' => $this->title, 
+            'description' => 'Purchase of Product #' . $this->id,
+        ];
+    }
+}
+```
+
+Example with a limited number of products:
+```php
+use Bavix\Wallet\Traits\HasWallet;
+use Bavix\Wallet\Interfaces\Customer;
+use Bavix\Wallet\Interfaces\ProductLimitedInterface;
+
+class Item extends Model implements ProductLimitedInterface
 {
     use HasWallet;
 
     public function canBuy(Customer $customer, int $quantity = 1, bool $force = false): bool
     {
         /**
+         * This is where you implement the constraint logic. 
+         * 
          * If the service can be purchased once, then
          *  return !$customer->paid($this);
          */
         return true; 
     }
-
+    
     public function getAmountProduct(Customer $customer)
     {
-        return round($this->price * 100);
+        return 100;
     }
 
     public function getMetaProduct(): ?array
     {
         return [
             'title' => $this->title, 
-            'description' => 'Purchase of Product #' . $this->getKey(), 
+            'description' => 'Purchase of Product #' . $this->id,
         ];
     }
 }
 ```
 
+I do not recommend using the limited interface when working with a shopping cart.
+If you are working with a shopping cart, then you should override the `PurchaseServiceInterface` interface.
+With it, you can check the availability of all products with one request, there will be no N-queries in the database.
+
 ## Fill the cart
 
 Find the user and check the balance.

diff --git a/docs/credit-limits.md b/docs/credit-limits.md
@@ -11,7 +11,7 @@ An example of working with a credit limit:
 /**
  * @var \Bavix\Wallet\Interfaces\Customer $customer
  * @var \Bavix\Wallet\Models\Wallet $wallet
- * @var \Bavix\Wallet\Interfaces\Product $product
+ * @var \Bavix\Wallet\Interfaces\ProductInterface $product
  */
 $wallet = $customer->wallet; // get default wallet
 $wallet->meta['credit'] = 10000; // credit limit

diff --git a/docs/gift.md b/docs/gift.md
@@ -16,26 +16,58 @@ class User extends Model implements Customer
 
 ## Item Model
 
-Add the `HasWallet` trait and `Product` interface to Item model.
+Add the `HasWallet` trait and interface to `Item` model.
 
+Starting from version 9.x there are two product interfaces:
+- For an unlimited number of products (`ProductLimitedInterface`);
+- For a limited number of products (`ProductInterface`);
+
+An example with an unlimited number of products:
 ```php
 use Bavix\Wallet\Traits\HasWallet;
-use Bavix\Wallet\Interfaces\Product;
 use Bavix\Wallet\Interfaces\Customer;
+use Bavix\Wallet\Interfaces\ProductInterface;
 
-class Item extends Model implements Product
+class Item extends Model implements ProductInterface
+{
+    use HasWallet;
+
+    public function getAmountProduct(Customer $customer)
+    {
+        return 100;
+    }
+
+    public function getMetaProduct(): ?array
+    {
+        return [
+            'title' => $this->title, 
+            'description' => 'Purchase of Product #' . $this->id,
+        ];
+    }
+}
+```
+
+Example with a limited number of products:
+```php
+use Bavix\Wallet\Traits\HasWallet;
+use Bavix\Wallet\Interfaces\Customer;
+use Bavix\Wallet\Interfaces\ProductLimitedInterface;
+
+class Item extends Model implements ProductLimitedInterface
 {
     use HasWallet;
 
     public function canBuy(Customer $customer, int $quantity = 1, bool $force = false): bool
     {
         /**
+         * This is where you implement the constraint logic. 
+         * 
          * If the service can be purchased once, then
          *  return !$customer->paid($this);
          */
         return true; 
     }
-
+    
     public function getAmountProduct(Customer $customer)
     {
         return 100;
@@ -51,6 +83,10 @@ class Item extends Model implements Product
 }
 ```
 
+I do not recommend using the limited interface when working with a shopping cart.
+If you are working with a shopping cart, then you should override the `PurchaseServiceInterface` interface.
+With it, you can check the availability of all products with one request, there will be no N-queries in the database.
+
 ## Santa Claus, give gifts
 
 Find the user's and check the balance.

diff --git a/docs/pay-free.md b/docs/pay-free.md
@@ -16,26 +16,58 @@ class User extends Model implements Customer
 
 ## Item Model
 
-Add the `HasWallet` trait and `Product` interface to Item model.
+Add the `HasWallet` trait and interface to `Item` model.
 
+Starting from version 9.x there are two product interfaces:
+- For an unlimited number of products (`ProductLimitedInterface`);
+- For a limited number of products (`ProductInterface`);
+
+An example with an unlimited number of products:
 ```php
 use Bavix\Wallet\Traits\HasWallet;
-use Bavix\Wallet\Interfaces\Product;
 use Bavix\Wallet\Interfaces\Customer;
+use Bavix\Wallet\Interfaces\ProductInterface;
 
-class Item extends Model implements Product
+class Item extends Model implements ProductInterface
+{
+    use HasWallet;
+
+    public function getAmountProduct(Customer $customer)
+    {
+        return 100;
+    }
+
+    public function getMetaProduct(): ?array
+    {
+        return [
+            'title' => $this->title, 
+            'description' => 'Purchase of Product #' . $this->id,
+        ];
+    }
+}
+```
+
+Example with a limited number of products:
+```php
+use Bavix\Wallet\Traits\HasWallet;
+use Bavix\Wallet\Interfaces\Customer;
+use Bavix\Wallet\Interfaces\ProductLimitedInterface;
+
+class Item extends Model implements ProductLimitedInterface
 {
     use HasWallet;
 
     public function canBuy(Customer $customer, int $quantity = 1, bool $force = false): bool
     {
         /**
+         * This is where you implement the constraint logic. 
+         * 
          * If the service can be purchased once, then
          *  return !$customer->paid($this);
          */
         return true; 
     }
-
+    
     public function getAmountProduct(Customer $customer)
     {
         return 100;
@@ -51,6 +83,10 @@ class Item extends Model implements Product
 }
 ```
 
+I do not recommend using the limited interface when working with a shopping cart.
+If you are working with a shopping cart, then you should override the `PurchaseServiceInterface` interface.
+With it, you can check the availability of all products with one request, there will be no N-queries in the database.
+
 ## Pay Free
 
 Find the user and check the balance.

diff --git a/docs/payment.md b/docs/payment.md
@@ -16,26 +16,58 @@ class User extends Model implements Customer
 
 ## Item Model
 
-Add the `HasWallet` trait and `Product` interface to Item model.
+Add the `HasWallet` trait and interface to `Item` model.
 
+Starting from version 9.x there are two product interfaces:
+- For an unlimited number of products (`ProductLimitedInterface`);
+- For a limited number of products (`ProductInterface`);
+
+An example with an unlimited number of products:
 ```php
 use Bavix\Wallet\Traits\HasWallet;
-use Bavix\Wallet\Interfaces\Product;
 use Bavix\Wallet\Interfaces\Customer;
+use Bavix\Wallet\Interfaces\ProductInterface;
 
-class Item extends Model implements Product
+class Item extends Model implements ProductInterface
+{
+    use HasWallet;
+
+    public function getAmountProduct(Customer $customer)
+    {
+        return 100;
+    }
+
+    public function getMetaProduct(): ?array
+    {
+        return [
+            'title' => $this->title, 
+            'description' => 'Purchase of Product #' . $this->id,
+        ];
+    }
+}
+```
+
+Example with a limited number of products:
+```php
+use Bavix\Wallet\Traits\HasWallet;
+use Bavix\Wallet\Interfaces\Customer;
+use Bavix\Wallet\Interfaces\ProductLimitedInterface;
+
+class Item extends Model implements ProductLimitedInterface
 {
     use HasWallet;
 
     public function canBuy(Customer $customer, int $quantity = 1, bool $force = false): bool
     {
         /**
+         * This is where you implement the constraint logic. 
+         * 
          * If the service can be purchased once, then
          *  return !$customer->paid($this);
          */
         return true; 
     }
-
+    
     public function getAmountProduct(Customer $customer)
     {
         return 100;
@@ -51,6 +83,10 @@ class Item extends Model implements Product
 }
 ```
 
+I do not recommend using the limited interface when working with a shopping cart.
+If you are working with a shopping cart, then you should override the `PurchaseServiceInterface` interface.
+With it, you can check the availability of all products with one request, there will be no N-queries in the database.
+
 ## Proceed to purchase
 
 Find the user and check the balance.