src/Entity/Purchase.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\ORM\Mapping as ORM;
  9. use \DateTime as DateTime;
  10. use \DateInterval as DateInterval;
  12. /**
  13.  * @ORM\Entity(repositoryClass="App\Repository\PurchaseRepository")
  14.  * 
  15.  * This class is the equivalent of the user's shopping cart. Users can add multiple purchase items into
  16.  * their Purchase items
  17.  */
  18. class Purchase
  19. {
  20.     
  21.     const STATUS_PROCESSING = -2;   //< status not in use currently 
  22.     const STATUS_ACTIVE = -1;       //< means that the purchase / cart is being edited still.. - TODO change to "current"
  23.     const STATUS_FAILED = 0;        //< means that the purchase / cart order failed...
  24.     const STATUS_PROCESSED = 1;     //< means that the purchase / cart is done and paid for...
  25.     
  26.     /**
  27.      * @ORM\Id()
  28.      * @ORM\GeneratedValue()
  29.      * @ORM\Column(type="integer")
  30.      */
  31.     private $id;
  32.     
  33.     /**
  34.      * @ORM\Version @ORM\Column(type="integer")
  35.      */
  36.     private $version;
  38.     /**
  39.      * @ORM\OneToMany(targetEntity="App\Entity\PurchaseItem", mappedBy="purchase", cascade={"persist"})
  40.      * @ORM\JoinColumn(nullable=true)
  41.      */
  42.     private $items;
  44.     /**
  45.      * @ORM\Column(type="bigint")
  46.      */
  47.     private $total;
  48.     
  49.     /**
  50.      * @ORM\Column(type="bigint")
  51.      */
  52.     private $discount;
  53.     
  54.     /**
  55.      * @ORM\Column(type="bigint")
  56.      */
  57.     private $tax;
  58.     
  59.     
  60.     /**
  61.      * @ORM\Column(type="string", length=255) - not used
  62.      */
  63.     private $customer;
  65.     /**
  66.      * @ORM\Column(type="string", length=255)
  67.      */
  68.     private $address_line_1;
  70.     /**
  71.      * @ORM\Column(type="string", length=255)
  72.      */
  73.     private $address_line_2;
  75.     /**
  76.      * @ORM\Column(type="string", length=255)
  77.      */
  78.     private $city;
  80.     /**
  81.      * @ORM\Column(type="string", length=255)
  82.      */
  83.     private $state_province;
  85.     /**
  86.      * @ORM\Column(type="string", length=32)
  87.      */
  88.     private $postal_code;
  90.     /**
  91.      * @ORM\Column(type="string", length=255)
  92.      */
  93.     private $country;
  95.     /**
  96.      * @ORM\Column(type="string", length=255)
  97.      */
  98.     private $company;
  100.     /**
  101.      * @ORM\Column(type="string", length=255)
  102.      */
  103.     private $email;
  105.     /**
  106.      * @ORM\Column(type="string", length=32)
  107.      */
  108.     private $phone;
  110.     /**
  111.      * @ORM\Column(type="string", length=4)
  112.      */
  113.     private $last4;
  115.     /**
  116.      * @ORM\Column(type="string", length=128)
  117.      */
  118.     private $transaction_number;
  120.     /**
  121.      * @ORM\Column(type="datetime", nullable=true)
  122.      * 
  123.      * not sure if this is used...
  124.      */
  125.     private $recurring_date;
  127.     /**
  128.      * @ORM\Column(type="datetime", nullable=true)
  129.      */
  130.     private $modified_at;
  132.     /**
  133.      * @ORM\Column(type="datetime", nullable=true)
  134.      */
  135.     private $created_at;
  137.     /**
  138.      * @ORM\OneToMany(targetEntity="App\Entity\PurchaseNote", mappedBy="purchase", cascade={"persist"})
  139.      */
  140.     private $purchaseNotes;
  142.     /**
  143.      * @ORM\ManyToOne(targetEntity="App\Entity\User", inversedBy="purchases")
  144.      * @ORM\JoinColumn(nullable=true)
  145.      */
  146.     private $user;
  148.     /**
  149.      * @ORM\Column(type="text", nullable=true)
  150.      */
  151.     private $raw_response;
  153.     /**
  154.      * @ORM\Column(type="string", length=255)
  155.      */
  156.     private $user_agent;
  158.     /**
  159.      * @ORM\Column(type="string", length=64)
  160.      */
  161.     private $user_ip;
  163.     /**
  164.      * @ORM\Column(type="integer")
  165.      */
  166.     private $status;
  168.     /**
  169.      * @ORM\Column(type="string", length=255)
  170.      */
  171.     private $first_name;
  173.     /**
  174.      * @ORM\Column(type="string", length=255)
  175.      */
  176.     private $last_name;
  178.     /**
  179.      * @ORM\Column(type="string", length=16)
  180.      */
  181.     private $expiration_date;
  183.     /**
  184.      * @ORM\Column(type="datetime")
  185.      */
  186.     private $purchased_at;
  188.     /**
  189.      * @ORM\Column(type="bigint")
  190.      */
  191.     private $purchased_amount;
  193.     /**
  194.      * @ORM\Column(type="text")
  195.      */
  196.     private $purchased_data;
  198.     /**
  199.      * @ORM\ManyToMany(targetEntity="App\Entity\Coupon", inversedBy="purchases")
  200.      */
  201.     private $coupons;
  203.     /**
  204.      * @ORM\Column(type="boolean")
  205.      */
  206.     private $terms_agree;
  207.     
  208.     
  209.     /**
  210.      * @ORM\Column(type="string", length=255)
  211.      */
  212.     private $shipping_first_name;
  214.     /**
  215.      * @ORM\Column(type="string", length=255)
  216.      */
  217.     private $shipping_last_name;
  218.     
  219.     /**
  220.      * @ORM\Column(type="string", length=255)
  221.      */
  222.     private $shipping_company;
  223.     
  224.     /**
  225.      * @ORM\Column(type="string", length=255)
  226.      */
  227.     private $shipping_country;
  228.     
  229.     /**
  230.      * @ORM\Column(type="string", length=255)
  231.      */
  232.     private $shipping_address_line_1;
  234.     /**
  235.      * @ORM\Column(type="string", length=255)
  236.      */
  237.     private $shipping_address_line_2;
  239.     /**
  240.      * @ORM\Column(type="string", length=255)
  241.      */
  242.     private $shipping_city;
  244.     /**
  245.      * @ORM\Column(type="string", length=255)
  246.      */
  247.     private $shipping_state_province;
  249.     /**
  250.      * @ORM\Column(type="string", length=32)
  251.      */
  252.     private $shipping_postal_code;
  254.     /**
  255.      * @ORM\Column(type="boolean")
  256.      */
  257.     private $admin_quick_purchase;
  258.     
  259.     
  261.     public function __construct()
  262.     {
  263.         $this->total = 0;
  264.         $this->first_name = "";
  265.         $this->last_name = "";
  266.         $this->customer = "";
  267.         $this->address_line_1 = "";
  268.         $this->address_line_2 = "";
  269.         $this->city = "";
  270.         $this->state_province = "";
  271.         $this->postal_code = "";
  272.         $this->country = "";
  273.         $this->company = "";
  274.         $this->email = "";
  275.         $this->phone = "";
  276.         $this->last4 = "";
  277.         $this->transaction_number = "";
  278.         $this->recurring_date = null;
  279.         $this->modified_at = new \DateTime("now");
  280.         $this->created_at = new \DateTime("now");
  281.         $this->raw_response = "";
  282.         $this->user_agent = "";
  283.         $this->user_ip = "";
  284.         $this->status = self::STATUS_ACTIVE;
  285.         
  286.         $this->items = new ArrayCollection();
  287.         $this->purchaseNotes = new ArrayCollection();
  288.         
  289.         // is this considered too personal? - won't store for now...
  290.         $this->expiration_date = "";
  291.         $this->purchased_at = new \DateTime("now");
  292.         $this->coupons = new ArrayCollection();
  293.         
  294.         $this->terms_agree = 0;
  295.         $this->admin_quick_purchase = 0;
  296.         $this->purchased_data = "";
  297.         $this->purchased_amount = 0;
  298.         $this->discount = 0;
  299.         $this->tax = 0;
  300.         
  301.         
  302.         $this->shipping_first_name = "";
  303.         $this->shipping_last_name = "";
  304.         $this->shipping_company = "";
  305.         $this->shipping_country = "";
  306.         $this->shipping_address_line_1 = "";
  307.         $this->shipping_address_line_2 = "";
  308.         $this->shipping_city = "";
  309.         $this->shipping_state_province = "";
  310.         $this->shipping_postal_code = "";
  311.     }
  313.     public function getId()
  314.     {
  315.         return $this->id;
  316.     }
  317.     
  318.     public function getVersion() {
  319.         return $this->version;
  320.     }
  321.     
  322.     public function getInvoiceNumber ()
  323.     {
  324.         return str_pad($this->id, 8, "0", STR_PAD_LEFT);
  325.     }
  326.     
  327.     /**
  328.      * @return Collection|PurchaseNote[]
  329.      */
  330.     public function  aseNotes(): Collection
  331.     {
  332.         return $this->purchaseNotes;
  333.     }
  335.     public function addPurchaseNote(purchaseNote $purchaseNote): self
  336.     {
  337.         if (!$this->purchaseNotes->contains($purchaseNote)) {
  338.             $this->purchaseNotes[] = $purchaseNote;
  339.             $purchaseNote->setPurchase($this);
  340.         }
  342.         return $this;
  343.     }
  345.     public function removePurchaseNote(purchaseNote $purchaseNote): self
  346.     {
  347.         if ($this->purchaseNotes->contains($purchaseNote)) {
  348.             $this->purchaseNotes->removeElement($purchaseNote);
  349.             // set the owning side to null (unless already changed)
  350.             if ($purchaseNote->getPurchase() === $this) {
  351.                 $purchaseNote->setPurchase(null);
  352.             }
  353.         }
  355.         return $this;
  356.     }
  357.     
  358.     public function getPurchaseNotes()
  359.     {
  360.         return $this->purchaseNotes;
  361.     }
  363.     public function getUser(): ?User
  364.     {
  365.         return $this->user;
  366.     }
  368.     public function setUser(?User $user): self
  369.     {
  370.         $this->user = $user;
  372.         return $this;
  373.     }
  374.     
  375.     public function getCurrentItem (): ?PurchaseItem
  376.     {
  377.         for ($i = 0; $i < count($this->items); $i++) {
  378.             $item = $this->items[$i];
  379.             if ($item->getStatus() == PurchaseItem::STATUS_CURRENT) {
  380.                 return $item;
  381.             }
  382.         }
  383.         return null;
  384.     }
  385.     
  386.     /**
  387.      * This function will overwrite previous purchase item - not sure if this will cause issues
  388.      * when purchasing between directory and classified listing
  389.      */
  390.     public function setCurrentItem (PurchaseItem $item): self
  391.     {
  392.         $item->setStatus(PurchaseItem::STATUS_CURRENT);
  393.         
  394.         // add the total if available
  395.         $product = $item->getProduct();
  396.         if ($product) {
  397.             $this->total += $product->getPrice();
  398.         }
  399.         
  400.         for ($i = 0; $i < count($this->items); $i++) {
  401.             $temp = $this->items[$i];
  402.             if ($temp->getStatus() == PurchaseItem::STATUS_CURRENT) {
  403.                 $this->items[$i] = $item;
  404.                 $item->setPurchase($this);
  405.                 return $this;
  406.             }
  407.         }
  408.         
  409.         // if reached simply add to end of array
  410.         $this->items[] = $item;
  411.         return $this;
  412.     }
  414.     /**
  415.      * @return Collection|PurchaseItem[]
  416.      */
  417.     public function getItems(): Collection
  418.     {
  419.         return $this->items;
  420.     }
  421.     
  422.     public function addItem(PurchaseItem $item): self
  423.     {
  424.         if (!$this->items->contains($item)) {
  425.             $this->items[] = $item;
  426.             $item->setPurchase($this);
  427.         }
  429.         return $this;
  430.     }
  431.     
  432.     public function countTotalItems(): int
  433.     {
  434.         $count = 0;
  435.         foreach($this->getItems() as $item) {
  436.             $count += $item->getQuantity();
  437.         }
  438.         return $count;
  439.     }
  441.     public function removeItem(PurchaseItem $item): self
  442.     {
  443.         if ($this->items->contains($item)) {
  444.             $this->items->removeElement($item);
  445.             // set the owning side to null (unless already changed)
  446.             if ($item->getPurchase() === $this) {
  447.                 $item->setPurchase(null);
  448.             }
  449.         }
  451.         return $this;
  452.     }
  453.     
  454.     public function getProductTypes() {
  455.         $productTypes = [];
  456.         foreach($this->items as $item) {
  457.             if(!in_array($item->getType(), $productTypes)) {
  458.                 $productTypes[] = $item->getType();
  459.             }
  460.         }
  461.         
  462.         foreach($productTypes as &$type) {
  463.             if($type == "classified") {
  464.                 $type = "Classified Listing";
  465.             }
  466.             elseif($type == "directory") {
  467.                 $type = "Directory Listing";
  468.             }
  469.             elseif($type == "shop") {
  470.                 $type = "RCS Gift Shop";
  471.             }
  472.             elseif($type == "membership") {
  473.                 $type = "R-Club Membership";
  474.             }
  475.             else {
  476.                 $type = ucwords($type);
  477.             }
  478.         }
  479.         return implode(", ", $productTypes);
  480.     }
  481.     
  482.     /**
  483.      * Should be called when a purchase is finalized. - this will serialize all of the product data,
  484.      * and coupon data to keep a historical record of the purchase - this is because entity
  485.      * relations will change and update over time but we want to keep some history the same
  486.      */
  487.     public function finalize ()
  488.     {
  489.         $items = [];
  490.         for ($i = 0; $i < count($this->items); $i++) {
  491.             $item = $this->items[$i];
  492.             $items[] = $item->toJSON();
  493.         }
  494.         
  495.         $coupons = [];
  496.         for ($i = 0; $i < count($this->coupons); $i++) {
  497.             $coupon = $this->coupons[$i];
  498.             $coupons[] = $coupon->toJSON();
  499.         }
  500.         $breakdownJson = $this->calculateBreakdown();
  501.         $breakdownJson = substr($breakdownJson["json"], 1, -1); //remove the outer {}'s since we're placing in json below
  502.         
  503.         // store the data
  504.         $this->purchased_data = '{"items":['.implode(",", $items).'],"coupons":['.implode(",", $coupons).'],'.$breakdownJson.'}';
  505.         $this->purchased_amount = $this->calculateTotal();
  506.         
  507.     }
  508.     
  509.     //return an array of the purchase breakdown (subtotal, discounts, taxes, total, and all by type)
  510.     public function calculateBreakdown ($items = null, $coupons = null)
  511.     {
  512.         if(is_null($items)) {
  513.             $items = $this->items;
  514.         }
  515.         if(is_null($coupons)) {
  516.             $coupons = $this->getCoupons();
  517.         }
  518.         
  519.         $subTotalsPerType = [];
  520.         $discountsPerType = [];
  521.         $taxesPerType = [];
  522.         $finalsPerType = [];
  523.         
  524.         for ($i = 0; $i < count($items); $i++) {
  525.             
  526.             $amount = $items[$i]->getAmount();
  527.             $product = $items[$i]->getProduct();
  528.             if (!$amount) {
  529.                 $amount = $product->getPrice();
  530.             }
  531.             
  532.             if(!isset($subTotalsPerType[$product->getType()])) {
  533.                 $subTotalsPerType[$product->getType()] = 0;
  534.                 $discountsPerType[$product->getType()] = 0;
  535.                 $taxesPerType[$product->getType()] = 0;
  536.             }
  537.             $subTotalsPerType[$product->getType()] += $amount;
  538.         }
  539.         
  540.         // apply any assigned coupons... and double check that coupons are valid  
  541.         foreach ($coupons as $coupon) {
  542.             
  543.             //amount discount for this coupon
  544.             $amount = 0;
  545.             
  546.             $prod_type = $coupon->getProductType();
  547.             
  548.             if(!isset($subTotalsPerType[$prod_type])) {
  549.                 continue;
  550.             }
  551.             
  552.             //$subTotalsPerType[$prod_type];
  553.             
  554.             switch ($coupon->getType()) {
  555.                 
  556.                 case Coupon::TYPE_DISCOUNT:
  557.                     $amount = $coupon->getAmount();
  558.                     
  559.                     if (strpos($amount, ".") === false) {
  560.                         $amount = "{$amount}00";
  561.                     }
  562.                     
  563.                     $amount = preg_replace("/[^0-9]*/", "", $amount);
  564.                     break;
  565.                     
  566.                 case Coupon::TYPE_PERCENTAGE:
  567.                     $amount = $coupon->getAmount();
  568.                     /*
  569.                     if (strpos($amount, "%") !== false) {
  570.                         // percentage amount
  571.                         $amount = str_replace("%", "", $amount);
  572.                         $amount = (double) $amount / 100;
  573.                         $amount = ($total * $amount);
  574.                     }
  575.                     
  576.                     else if (strpos($amount, ".") !== false) {
  577.                         // fraction amount
  578.                         $amount = (double) $amount;
  579.                         $amount = ($total * $amount);
  580.                     }*/
  581.                     $amount = (double) $amount / 100;
  582.                     $amount = ($subTotalsPerType[$prod_type] * $amount);
  583.                     
  584.                     break;
  585.                     
  586.                 case Coupon::TYPE_FREE_PRODUCT:
  587.                     $couponProducts = $coupon->getProducts();
  588.                     // see if we have this product currently attached to the purchase
  589.                     for ($j = 0; $j < count($items); $j++) {
  590.                         $product = $items[$j]->getProduct();
  591.                         
  592.                         // if the coupon contains the product add the amount to the discount
  593.                         if ($couponProducts->contains($product)) {
  594.                             $amount = $product->getPrice();
  595.                             // set the amount in the coupon... since it was not provided
  596.                             $coupon->setAmount($product->getPrice());
  597.                             break;
  598.                         }
  599.                     }
  600.                     break;
  601.             }
  602.             
  603.             if ($amount) {
  604.                 $discountsPerType[$prod_type] += $amount;
  605.                 $discountsPerType[$prod_type] = min($discountsPerType[$prod_type], $subTotalsPerType[$prod_type]); //can't discount > 100%
  606.             }
  607.             
  608.         }
  609.         
  610.         $subtotal = 0;
  611.         $discount = 0;
  612.         $tax = 0;
  613.         $final = 0;
  614.         
  615.         foreach($subTotalsPerType as $prod_type => $total) {
  616.             
  617.             $subtotal += $total;
  618.             
  619.             $finalsPerType[$prod_type] = $subTotalsPerType[$prod_type] - $discountsPerType[$prod_type];
  620.             
  621.             //Calculate taxes. Current only taxing gift shop items, all purchases use California's sales tax rate.
  622.             if($prod_type == Product::PRODUCT_TYPE_SHOP) {
  623.                 $tax_rate = 0.0725;
  624.                 $taxesPerType[$prod_type] = $finalsPerType[$prod_type] * $tax_rate;
  625.                 
  626.                 $finalsPerType[$prod_type] += $taxesPerType[$prod_type];
  627.             }
  628.             
  629.             $discount += $discountsPerType[$prod_type];
  630.             $tax += $taxesPerType[$prod_type];
  631.             $final += $finalsPerType[$prod_type];
  632.             
  633.         }
  634.         
  635.         $this->discount = $discount;
  636.         $this->tax = $tax;
  637.         
  638.         $return = [
  639.             "total" => $final,
  640.             "json" => json_encode([
  641.                 "subTotalsPerType" => $subTotalsPerType,
  642.                 "discountsPerType" => $discountsPerType,
  643.                 "taxesPerType" => $taxesPerType,
  644.                 "finalsPerType" => $finalsPerType,
  645.                 "subtotal" => $subtotal,
  646.                 "discount" => $discount,
  647.                 "tax" => $tax,
  648.                 "total" => $final,
  649.             ])
  650.         ];
  651.         
  652.         return $return;
  653.         //return $final;
  654.         
  655.     }
  656.     
  657.     //Check if this purchase requires shipping info. Currently includes all gift shop items.
  658.     public function requiresShipping(): ?bool {
  659.         $require_shipping = false;
  660.         
  661.         foreach($this->items as $item) {
  662.             $product = $item->getProduct();
  663.             if($product->getType() == Product::PRODUCT_TYPE_SHOP) {
  664.                 $require_shipping = true;
  665.             }
  666.         }
  667.         
  668.         return $require_shipping;
  669.     }
  670.     
  671.     //Check if this purchase will require billing; either now, or in the future if recurring and coupons expire
  672.     public function requiresBilling(): ?bool {
  673.         
  674.         if($this->calculateTotal() > 0) {
  675.             return true;
  676.         }
  677.         
  678.         $recurringItems = [];
  679.         $recurringCoupons = [];
  680.         
  681.         foreach($this->items as $item) {
  682.             $product = $item->getProduct();
  683.             if($product->getPaymentRate() && ($product->getPaymentRate() != "none")) {
  684.                 $recurringItems[] = $item;
  685.             }
  686.         }
  687.         
  688.         foreach($this->getCoupons() as $coupon) {
  689.             if($coupon->getRecurringType() == Coupon::RECURRING_UNLIMITED) {
  690.                 $recurringCoupons[] = $coupon;
  691.             }
  692.         }
  693.         
  694.         $breakdown = $this->calculateBreakdown($recurringItems, $recurringCoupons);
  695.         $total = $breakdown["total"];
  696.         return $total > 0;
  697.     }
  698.     
  699.     public function calculateTotal (): ?int
  700.     {
  701.         $breakdown = $this->calculateBreakdown();
  702.         return $breakdown["total"];
  703.     }
  704.     
  705.     //Return the total without any discounts / taxes
  706.     public function calculateSubTotal (): ?int
  707.     {    
  708.         $subtotal = 0;
  709.         
  710.         for ($i = 0; $i < count($this->items); $i++) {
  711.             $amount = $this->items[$i]->getAmount();            
  712.             if (!$amount) {
  713.                 $product = $this->items[$i]->getProduct();
  714.                 $amount = $product->getPrice();
  715.             }
  716.             $subtotal += $amount;
  717.         }
  718.         return $subtotal;
  719.     }
  721.     public function getTotal(): ?int
  722.     {
  723.         $total = $this->calculateTotal();
  724.         /*
  725.         $total = 0;
  726.         for ($i = 0; $i < count($this->items); $i++) {
  727.             $amount = $this->items[$i]->getAmount();
  728.             if (!$amount) {
  729.                 $product = $this->items[$i]->getProduct();
  730.                 $amount = $product->getPrice();
  731.             }
  732.             $total += $amount;
  733.         }
  734.         
  735.         // apply any assigned coupons... and make sure coupons are valid
  736.         */
  737.         
  738.         $this->total = $total;
  739.         
  740.         return $this->total;
  741.     }
  742.     
  743.     public function getSubTotalUsd ($asDecimal = false): string
  744.     {
  745.         $total = $this->calculateSubTotal();
  746.         if ($asDecimal) {
  747.             return number_format(($total / 100), 2, ".", "");   
  748.         } else {
  749.             return "$" . number_format(($total / 100), 2);
  750.         }
  751.     }
  752.     
  753.     public function getTotalUsd ($asDecimal = false): string
  754.     {
  755.         $total = $this->getTotal();
  756.         if ($asDecimal) {
  757.             return number_format(($total / 100), 2, ".", "");   
  758.         } else {
  759.             return "$" . number_format(($total / 100), 2);
  760.         }
  761.     }
  763.     public function setTotal(int $total): self
  764.     {
  765.         $this->total = $total;
  767.         return $this;
  768.     }
  769.     
  770.     //Total discount
  771.     public function getDiscount(): ?int
  772.     {
  773.         return $this->discount;
  774.     }
  775.     
  776.     public function getDiscountUsd ($asDecimal = false): string
  777.     {
  778.         $discount = $this->getDiscount();
  779.         if ($asDecimal) {
  780.             return number_format(($discount / 100), 2, ".", "");   
  781.         } else {
  782.             return "$" . number_format(($discount / 100), 2);
  783.         }
  784.     }
  786.     public function setDiscount(int $discount): self
  787.     {
  788.         $this->discount = $discount;
  790.         return $this;
  791.     }
  792.     
  793.     //Total taxes
  794.     public function getTax(): ?int
  795.     {
  796.         return $this->tax;
  797.     }
  798.     
  799.     public function getTaxUsd ($asDecimal = false): string
  800.     {
  801.         $tax = $this->getTax();
  802.         if ($asDecimal) {
  803.             return number_format(($tax / 100), 2, ".", "");   
  804.         } else {
  805.             return "$" . number_format(($tax / 100), 2);
  806.         }
  807.     }
  809.     public function setTax(int $tax): self
  810.     {
  811.         $this->tax = $tax;
  812.         
  813.         return $this;
  814.     }
  815.     
  816.     public function getRecurringDate(): ?\DateTimeInterface
  817.     {
  818.         return $this->recurring_date;
  819.     }
  821.     public function setRecurringDate(\DateTimeInterface $recurring_date): self
  822.     {
  823.         $this->recurring_date = $recurring_date;
  824.         return $this;
  825.     }
  826.     
  827.     public function getModifiedAt(): ?\DateTimeInterface
  828.     {
  829.         return $this->modified_at;
  830.     }
  832.     public function setModifiedAt(\DateTimeInterface $modified_at): self
  833.     {
  834.         $this->modified_at = $modified_at;
  835.         return $this;
  836.     }
  837.     
  838.     public function getCreatedAt(): ?\DateTimeInterface
  839.     {
  840.         return $this->created_at;
  841.     }
  843.     public function setCreatedAt(\DateTimeInterface $created_at): self
  844.     {
  845.         $this->created_at = $created_at;
  846.         return $this;
  847.     }
  849.     public function getStatus(): ?int
  850.     {
  851.         return $this->status;
  852.     }
  853.     
  854.     public function getStatusText (): string
  855.     {
  856.         switch ($this->status) {
  857.             case self::STATUS_PROCESSING:
  858.                 return "Processing";
  859.             case self::STATUS_ACTIVE:
  860.                 return "In Cart";
  861.             case self::STATUS_FAILED:
  862.                 return "Failed";
  863.             case self::STATUS_PROCESSED:
  864.             default:
  865.                 return "Processed";
  866.         }
  867.     }
  869.     public function setStatus(int $status): self
  870.     {
  871.         //return if the status didn't change
  872.         if($this->status == $status) {
  873.             return $this;
  874.         }
  875.         
  876.         $this->status = $status;
  877.         
  878.         // if the purchase is processed - move through all purchase items and content and set appropriate 
  879.         // renewal and expiration dates.
  880.         
  881.         if ($status == self::STATUS_PROCESSED) {
  882.             
  883.             $this->purchased_at = new \DateTime("now");
  884.             
  885.             // this should really be cleaned up to follow a better flow...
  886.             $this->finalize();
  887.             
  888.             for ($i = 0; $i < count($this->items); $i++) {
  889.                 $item = $this->items[$i];
  890.                 $product = $item->getProduct();
  891.                 $rate = strtoupper($product->getPaymentRate());
  892.                 $content = $item->getContent();
  893.                 
  894.                 // grab the purchased date
  895.                 $purchased = $this->getPurchasedAt();
  896.                 
  897.                 // 1 month interval default
  898.                 $interval = new DateInterval("P1M");
  899.                 $intervalSet = false;
  901.                 foreach($item->getProductOptionValues() as $productOptionValue) {
  902.                     $productOption = $productOptionValue->getProductOption();
  903.                     if($productOption && $productOption->getTitle() == "duration") {
  904.                         $interval = new DateInterval("P".$productOptionValue->getValue()."D");
  905.                         $intervalSet = true;
  906.                     }
  907.                 }
  909.                 if(!$intervalSet) {
  911.                     switch ($rate) {
  912.                         case Product::RENEW_MONTHLY:
  913.                             $interval = new DateInterval("P1M");
  914.                             break;
  915.                             
  916.                         case Product::RENEW_YEARLY:
  917.                             $interval = new DateInterval("P1Y");
  918.                             break;
  919.                             
  920.                         case Product::RENEW_NOT_SET:
  921.                         default: 
  922.                             // ugly hack ... try to determine from title of product...
  923.                             $title = $product->getTitle();
  924.                                                     
  925.                             if (stripos($title, "annual") !== false) {
  926.                                 $interval = new DateInterval("P1Y");
  927.                             }
  928.                             
  929.                             else if (stripos($title, "30 day") !== false) {
  930.                                 $interval = new DateInterval("P30D");
  931.                             }
  932.                             
  933.                             else if (stripos($title, "60 day") !== false) {
  934.                                 $interval = new DateInterval("P60D");
  935.                             }
  936.                             
  937.                             else if (stripos($title, "90 day") !== false) {
  938.                                 $interval = new DateInterval("P90D");
  939.                             }
  940.                             
  941.                             else {
  942.                                 // catch all - give the content 1 active month if can't figure out renewal time
  943.                                 $interval = new DateInterval("P1M");
  944.                             }
  945.                             break;
  946.                     }
  947.                     
  948.                 }
  949.                 
  950.                 // set the proper expiration times ... 
  951.                 if ($content) {
  952.                     // update the published at 
  953.                     $content->setPublishedAt(new DateTime("now"));
  954.                 
  955.                     $expires = $content->getExpiresAt();
  956.                     
  957.                     // if exists and is valid
  958.                     if ($expires && new DateTime("now") < $expires) {
  959.                         // content has not yet expired
  960.                         $expires = clone $expires;
  961.                         $content->setExpiresAt($expires->add($interval));
  962.                         $content->setStatus(Content::STATUS_ACTIVE);
  963.                     }
  964.                     
  965.                     else {
  966.                         // content has either expired or is invalid
  967.                         $expires = clone $purchased;
  968.                         $content->setExpiresAt($expires->add($interval));
  969.                         $content->setStatus(Content::STATUS_ACTIVE);
  970.                     }
  971.                 }
  972.                 
  973.                 //shop items don't expire
  974.                 if($product->getType() == Product::PRODUCT_TYPE_SHOP) {
  975.                     $item->setStatus(PurchaseItem::STATUS_ACTIVE);
  976.                 }
  977.                 else {
  978.                     // the below really shouldn't matter because we are making a new purchase item when renewing
  979.                     $expires = $item->getExpiresAt();
  980.                     if ($expires && new DateTime("now") < $expires) {
  981.                         $expires = clone $expires;
  982.                         $item->setExpiresAt($expires->add($interval));
  983.                         $item->setStatus(PurchaseItem::STATUS_ACTIVE);
  984.                     }
  985.                     
  986.                     else {
  987.                         // item
  988.                         $expires = clone $purchased;
  989.                         $item->setExpiresAt($expires->add($interval)); 
  990.                         $item->setStatus(PurchaseItem::STATUS_ACTIVE);                   
  991.                     }
  992.                 }
  993.                 
  994.                 $item->setMonthsRenewed(1);
  995.                 
  996.                 //Handle the RCS Club Membership product
  997.                 if($product->getType() == Product::PRODUCT_TYPE_MEMBERSHIP) {
  998.                     $user = $this->getUser();
  999.                     if($user) {
  1000.                         $user->setMember(1);
  1001.                         
  1002.                         //handle company memberships. should make this a different type, but for now just checking the title
  1003.                         if(strpos($product->getTitle(), 'Company') !== false) {
  1004.                             $user->setMember(2);
  1005.                         }
  1006.                         elseif(strpos($product->getTitle(), 'Contractor') !== false) {
  1007.                             $user->setMember(3);
  1008.                         }
  1009.                         
  1010.                         //Changed to opt-in
  1011.                         //if(strlen($user->getUserMetaValueByKey("member_notification_forum")) == 0) {$user->setUsermetum("member_notification_forum", "1");};
  1012.                         //if(strlen($user->getUserMetaValueByKey("member_notification_page")) == 0) {$user->setUsermetum("member_notification_page", "1");};
  1013.                         //if(strlen($user->getUserMetaValueByKey("member_notification_classifieds")) == 0) {$user->setUsermetum("member_notification_classifieds", "1");};
  1014.                         
  1015.                         //set to auto renew. should move this above when classified / directory auto renewal is working
  1016.                         $item->setStatus(PurchaseItem::STATUS_ACTIVE_RENEWING);
  1017.                     }
  1018.                 }
  1019.                 
  1020.                 
  1021.             }
  1022.             
  1023.             // all dates should be updated
  1024.             
  1025.             
  1026.         }
  1028.         return $this;
  1029.     }
  1030.     
  1031.     public function getCustomer(): ?string
  1032.     {
  1033.         return $this->customer;
  1034.     }
  1036.     public function setCustomer(string $customer = null): self
  1037.     {
  1038.         $this->customer = $customer ? $customer : "";
  1040.         return $this;
  1041.     }
  1043.     public function getAddressLine1(): ?string
  1044.     {
  1045.         return $this->address_line_1;
  1046.     }
  1048.     public function setAddressLine1(string $address_line_1 = null): self
  1049.     {
  1050.         $this->address_line_1 = $address_line_1 ? $address_line_1 : "";
  1052.         return $this;
  1053.     }
  1055.     public function getAddressLine2(): ?string
  1056.     {
  1057.         return $this->address_line_2;
  1058.     }
  1060.     public function setAddressLine2(string $address_line_2 = null): self
  1061.     {
  1062.         $this->address_line_2 = $address_line_2 ? $address_line_2 : "";
  1064.         return $this;
  1065.     }
  1067.     public function getCity(): ?string
  1068.     {
  1069.         return $this->city;
  1070.     }
  1072.     public function setCity(string $city = null): self
  1073.     {
  1074.         $this->city = $city ? $city : "";
  1076.         return $this;
  1077.     }
  1079.     public function getStateProvince(): ?string
  1080.     {
  1081.         return $this->state_province;
  1082.     }
  1084.     public function setStateProvince(string $state_province = null): self
  1085.     {
  1086.         $this->state_province = $state_province ? $state_province : "";
  1088.         return $this;
  1089.     }
  1091.     public function getPostalCode(): ?string
  1092.     {
  1093.         return $this->postal_code;
  1094.     }
  1096.     public function setPostalCode(string $postal_code = null): self
  1097.     {
  1098.         $this->postal_code = $postal_code ? $postal_code : "";
  1100.         return $this;
  1101.     }
  1103.     public function getCountry(): ?string
  1104.     {
  1105.         return $this->country;
  1106.     }
  1108.     public function setCountry(string $country = null): self
  1109.     {
  1110.         $this->country = $country ? $country : "";
  1112.         return $this;
  1113.     }
  1115.     public function getCompany(): ?string
  1116.     {
  1117.         return $this->company;
  1118.     }
  1120.     public function setCompany(string $company = null): self
  1121.     {
  1122.         $this->company = $company ? $company : "";
  1124.         return $this;
  1125.     }
  1127.     public function getEmail(): ?string
  1128.     {
  1129.         return $this->email;
  1130.     }
  1132.     public function setEmail(string $email = null): self
  1133.     {
  1134.         $this->email = $email ? $email : "";
  1136.         return $this;
  1137.     }
  1139.     public function getPhone(): ?string
  1140.     {
  1141.         return $this->phone;
  1142.     }
  1144.     public function setPhone(string $phone = null): self
  1145.     {
  1146.         $this->phone = $phone ? $phone : "";
  1148.         return $this;
  1149.     }
  1151.     public function getLast4(): ?string
  1152.     {
  1153.         return $this->last4;
  1154.     }
  1156.     public function setLast4(string $last4 = null): self
  1157.     {
  1158.         $this->last4 = $last4 ? $last4 : "";
  1160.         return $this;
  1161.     }
  1163.     public function getTransactionNumber()
  1164.     {
  1165.         return $this->transaction_number;
  1166.     }
  1168.     public function setTransactionNumber(string $transaction_number = null): self
  1169.     {
  1170.         $this->transaction_number = $transaction_number ? $transaction_number : "";
  1172.         return $this;
  1173.     }
  1174.     
  1175.     public function __toString ()
  1176.     {
  1177.         return "Purchase: {$this->id}";
  1178.     }
  1180.     public function getFirstName(): ?string
  1181.     {
  1182.         return $this->first_name;
  1183.     }
  1185.     public function setFirstName(string $first_name = null): self
  1186.     {
  1187.         $this->first_name = $first_name ? $first_name : "";
  1189.         return $this;
  1190.     }
  1192.     public function getLastName(): ?string
  1193.     {
  1194.         return $this->last_name;
  1195.     }
  1197.     public function setLastName(string $last_name = null): self
  1198.     {
  1199.         $this->last_name = $last_name ? $last_name : "";
  1201.         return $this;
  1202.     }
  1204.     public function getExpirationDate(): ?string
  1205.     {
  1206.         return $this->expiration_date;
  1207.     }
  1209.     public function setExpirationDate(string $expiration_date): self
  1210.     {
  1211.         $this->expiration_date = $expiration_date;
  1213.         return $this;
  1214.     }
  1215.     
  1216.     public function getRawResponse(): ?string
  1217.     {
  1218.         return $this->raw_response;
  1219.     }
  1221.     public function setRawResponse(?string $raw_response): self
  1222.     {
  1223.         $this->raw_response = $raw_response;
  1225.         return $this;
  1226.     }
  1228.     public function getUserAgent(): ?string
  1229.     {
  1230.         return $this->user_agent;
  1231.     }
  1233.     public function setUserAgent(string $user_agent): self
  1234.     {
  1235.         $this->user_agent = $user_agent;
  1237.         return $this;
  1238.     }
  1240.     public function getUserIp(): ?string
  1241.     {
  1242.         return $this->user_ip;
  1243.     }
  1245.     public function setUserIp(string $user_ip): self
  1246.     {
  1247.         $this->user_ip = $user_ip;
  1249.         return $this;
  1250.     }
  1252.     public function getPurchasedAt(): ?\DateTimeInterface
  1253.     {
  1254.         return $this->purchased_at;
  1255.     }
  1257.     public function setPurchasedAt(\DateTimeInterface $purchased_at): self
  1258.     {
  1259.         $this->purchased_at = $purchased_at;
  1261.         return $this;
  1262.     }
  1264.     public function getPurchasedAmount(): ?int
  1265.     {
  1266.         return $this->purchased_amount;
  1267.     }
  1269.     public function setPurchasedAmount(int $purchased_amount): self
  1270.     {
  1271.         $this->purchased_amount = $purchased_amount;
  1273.         return $this;
  1274.     }
  1276.     public function getPurchasedData(): ?string
  1277.     {
  1278.         return $this->purchased_data;
  1279.     }
  1281.     public function setPurchasedData(string $purchased_data): self
  1282.     {
  1283.         $this->purchased_data = $purchased_data;
  1285.         return $this;
  1286.     }
  1288.     /**
  1289.      * @return Collection|Coupon[]
  1290.      */
  1291.     public function getCoupons(): Collection
  1292.     {
  1293.         return $this->coupons;
  1294.     }
  1296.     public function addCoupon(Coupon $coupon): self
  1297.     {
  1298.         if (!$this->coupons->contains($coupon)) {
  1299.             $this->coupons[] = $coupon;
  1300.         }
  1302.         return $this;
  1303.     }
  1305.     public function removeCoupon(Coupon $coupon): self
  1306.     {
  1307.         if ($this->coupons->contains($coupon)) {
  1308.             $this->coupons->removeElement($coupon);
  1309.         }
  1311.         return $this;
  1312.     }
  1313.     
  1314.     public function removeCoupons (): self
  1315.     {
  1316.         foreach ($this->coupons as $coupon) {
  1317.             $this->removeCoupon($coupon);
  1318.         }
  1319.         return $this;
  1320.     }
  1322.     public function getTermsAgree(): ?bool
  1323.     {
  1324.         return $this->terms_agree;
  1325.     }
  1327.     public function setTermsAgree(bool $terms_agree): self
  1328.     {
  1329.         $this->terms_agree = $terms_agree;
  1331.         return $this;
  1332.     }
  1334.     public function getAdminQuickPurchase(): ?bool
  1335.     {
  1336.         return $this->admin_quick_purchase;
  1337.     }
  1339.     public function setAdminQuickPurchase(bool $admin_quick_purchase): self
  1340.     {
  1341.         $this->admin_quick_purchase = $admin_quick_purchase;
  1343.         return $this;
  1344.     }
  1345.     
  1346.     public function getBilling(): ?string
  1347.     {
  1348.         return $this->getFirstName() . " " . $this->getLastName() . ($this->getFirstName() ? ", " : "") .
  1349.         $this->getCompany() . ($this->getCompany() ? ", " : "") . $this->getAddressLine1() . " " .
  1350.         $this->getAddressLine2() . ($this->getAddressLine1() ? ", " : "") . $this->getCity() . ($this->getCity() ? ", " : "") .
  1351.         $this->getStateProvince() . ($this->getStateProvince() ? ", " : "") . $this->getPostalCode()
  1352.         ;
  1353.     }
  1354.     
  1355.     
  1356.     
  1357.         
  1358.     public function getShippingFirstName(): ?string
  1359.     {
  1360.         return $this->shipping_first_name;
  1361.     }
  1363.     public function setShippingFirstName(string $shipping_first_name = null): self
  1364.     {
  1365.         $this->shipping_first_name = $shipping_first_name ? $shipping_first_name : "";
  1367.         return $this;
  1368.     }
  1370.     public function getShippingLastName(): ?string
  1371.     {
  1372.         return $this->shipping_last_name;
  1373.     }
  1375.     public function setShippingLastName(string $shipping_last_name = null): self
  1376.     {
  1377.         $this->shipping_last_name = $shipping_last_name ? $shipping_last_name : "";
  1379.         return $this;
  1380.     }
  1381.     
  1382.     public function getShippingCompany(): ?string
  1383.     {
  1384.         return $this->shipping_company;
  1385.     }
  1387.     public function setShippingCompany(string $shipping_company = null): self
  1388.     {
  1389.         $this->shipping_company = $shipping_company ? $shipping_company : "";
  1391.         return $this;
  1392.     }
  1393.     
  1394.     public function getShippingCountry(): ?string
  1395.     {
  1396.         return $this->shipping_country;
  1397.     }
  1399.     public function setShippingCountry(string $shipping_country = null): self
  1400.     {
  1401.         $this->shipping_country = $shipping_country ? $shipping_country : "";
  1403.         return $this;
  1404.     }
  1405.     
  1406.     public function getShippingAddressLine1(): ?string
  1407.     {
  1408.         return $this->shipping_address_line_1;
  1409.     }
  1411.     public function setShippingAddressLine1(string $shipping_address_line_1 = null): self
  1412.     {
  1413.         $this->shipping_address_line_1 = $shipping_address_line_1 ? $shipping_address_line_1 : "";
  1415.         return $this;
  1416.     }
  1418.     public function getShippingAddressLine2(): ?string
  1419.     {
  1420.         return $this->shipping_address_line_2;
  1421.     }
  1423.     public function setShippingAddressLine2(string $shipping_address_line_2 = null): self
  1424.     {
  1425.         $this->shipping_address_line_2 = $shipping_address_line_2 ? $shipping_address_line_2 : "";
  1427.         return $this;
  1428.     }
  1430.     public function getShippingCity(): ?string
  1431.     {
  1432.         return $this->shipping_city;
  1433.     }
  1435.     public function setShippingCity(string $shipping_city = null): self
  1436.     {
  1437.         $this->shipping_city = $shipping_city ? $shipping_city : "";
  1439.         return $this;
  1440.     }
  1442.     public function getShippingStateProvince(): ?string
  1443.     {
  1444.         return $this->shipping_state_province;
  1445.     }
  1447.     public function setShippingStateProvince(string $shipping_state_province = null): self
  1448.     {
  1449.         $this->shipping_state_province = $shipping_state_province ? $shipping_state_province : "";
  1451.         return $this;
  1452.     }
  1454.     public function getShippingPostalCode(): ?string
  1455.     {
  1456.         return $this->shipping_postal_code;
  1457.     }
  1459.     public function setShippingPostalCode(string $shipping_postal_code = null): self
  1460.     {
  1461.         $this->shipping_postal_code = $shipping_postal_code ? $shipping_postal_code : "";
  1463.         return $this;
  1464.     }
  1465.     
  1466. }