DefaultPrices::separateTaxesFromOtherPrices() - Code Metrics - Inspection of "Daily Inspection: Moar Betterer Default Price and..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — dev (81ae86)

unknown

created 2021-02-01 21:41 UTC

DefaultPrices::separateTaxesFromOtherPrices() A

↳ Parent: DefaultPrices

Complexity

Conditions	5
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
nc	3
nop	1
dl	0
loc	18
rs	9.3554
c	0
b	0
f	0

<?php

namespace EventEspresso\core\domain\services\admin\entities;

use EE_Base_Class;
use EE_Error;
use EE_Price;
use EE_Price_Type;
use EE_Ticket;
use EEM_Price;
use EEM_Price_Type;
use EventEspresso\core\exceptions\InvalidEntityException;
use EventEspresso\core\exceptions\InvalidInterfaceException;
use ReflectionException;
use RuntimeException;

/**
 * Class DefaultPrices
 * Description
 *
 * @package EventEspresso\core\domain\services\admin\events\editor
 * @author  Brent Christensen
 * @since   $VID:$
 */
class DefaultPrices implements DefaultEntityGeneratorInterface
{

    /**
     * @var EEM_Price
     */
    protected $price_model;

    /**
     * @var EEM_Price_Type
     */
    protected $price_type_model;

    /**
     * @var EE_Price[]
     */
    protected $new_prices = [];

    /**
     * @var EE_Price[]
     */
    protected $taxes = [];


    /**
     * @param EEM_Price      $price_model
     * @param EEM_Price_Type $price_type_model
     */
    public function __construct(EEM_Price $price_model, EEM_Price_Type $price_type_model)
    {
        $this->price_model      = $price_model;
        $this->price_type_model = $price_type_model;
    }


    /**
     * @param EE_Ticket|EE_Base_Class $entity
     * @return EE_Price[]
     * @throws EE_Error
     * @throws InvalidInterfaceException
     * @throws ReflectionException
     * @since $VID:$
     */
    public function create(EE_Base_Class $entity): array
    {
        if (! $entity instanceof EE_Ticket) {
            throw new InvalidEntityException($entity, 'EE_Ticket');
        }
        $is_free                   = true;
        $has_base_price            = false;
        $remove_existing_relations = true;
        // first, let's get all of the default taxes for the site
        $this->taxes = $this->price_model->getAllDefaultTaxes();
        // then separate taxes from the other prices for the existing default ticket prices
        $default_prices = $this->separateTaxesFromOtherPrices($entity->prices());
        // but if that's empty, then let's get the default global prices
        if (empty($default_prices)) {
            $default_global_prices     = $this->price_model->get_all_default_prices();
            $default_prices            = $this->separateTaxesFromOtherPrices($default_global_prices);
            $remove_existing_relations = false;
        }
        // then clone and apply all of the default prices
        [$has_base_price, $is_free] = $this->cloneDefaultPrices(
            $entity,
            $default_prices,
            $remove_existing_relations,
            $has_base_price,
            $is_free
        );
        if (! $has_base_price) {
            $new_base_price                            = $this->createNewBasePrice($entity);
            $this->new_prices[ $new_base_price->ID() ] = $new_base_price;
        }
        $this->applyTaxes($entity, $is_free);
        $ticket_total = $entity->get_ticket_total_with_taxes(true);
        if ($ticket_total !== $entity->ticket_price()) {
            $entity->set_price($ticket_total);
            $entity->save();
        }
        return $this->new_prices;
    }


    /**
     * @param EE_Ticket $ticket
     * @param bool      $is_free
     * @throws EE_Error
     * @throws ReflectionException
     */
    private function applyTaxes(EE_Ticket $ticket, bool $is_free)
    {
        if (! $is_free && ! empty($this->taxes)) {
            foreach ($this->taxes as $tax) {
                // assign taxes but don't duplicate them because they operate globally
                $ticket->set_taxable(true);
                $tax->_add_relation_to($ticket, 'Ticket');
            }
        }
    }


    /**
     * @param EE_Ticket  $ticket
     * @param EE_Price[] $default_prices
     * @param bool       $remove_existing_relations
     * @param bool       $has_base_price
     * @param bool       $is_free
     * @return bool[]
     * @throws EE_Error
     * @throws ReflectionException
     */
    private function cloneDefaultPrices(
        EE_Ticket $ticket,
        array $default_prices,
        bool $remove_existing_relations,
        bool $has_base_price,
        bool $is_free
    ): array {
        foreach ($default_prices as $default_price) {
            // duplicate the default price so that it does not get mutated
            $default_price_clone = clone $default_price;
            if ($remove_existing_relations) {
                $ticket->_remove_relation_to($default_price, 'Price');
            }
            if ((
                    // has non-zero base price
                    $default_price_clone->is_base_price()
                    && $default_price_clone->amount() > 0
                )
                || (
                    // or has fixed amount surcharge
                    $default_price_clone->is_surcharge()
                    && ! $default_price_clone->is_percent()
                )
            ) {
                $is_free = false;
            }
            $is_base_price = $default_price_clone->is_base_price();
            // add this price to ticket if it is a regular price modifier, ie: NOT a base price,
            // OR if it IS a base price but this ticket does NOT already have a base price
            if (! $is_base_price || ! $has_base_price) {
                $default_price_clone->set('PRC_ID', null);
                $default_price_clone->set('PRC_is_default', false);
                $default_price_clone->save();
                $default_price_clone->_add_relation_to($ticket, 'Ticket');
                $this->new_prices[ $default_price_clone->ID() ] = $default_price_clone;
                // then recheck that a base price has been set so that we don't add another one
                $has_base_price = $is_base_price ? true : $has_base_price;
            }
        }
        return [$has_base_price, $is_free];
    }


    /**
     * @param EE_Ticket $ticket
     * @return EE_Price
     * @throws EE_Error
     * @throws ReflectionException
     */
    private function createNewBasePrice(EE_Ticket $ticket): EE_Price
    {
        $new_base_price  = $this->price_model->get_new_price();
        $base_price_type = $this->price_type_model->get_one(
            [
                [
                    'PBT_ID' => EEM_Price_Type::base_type_base_price,
                ],
            ]
        );
        if (! $base_price_type instanceof EE_Price_Type) {
            throw new RuntimeException(
                esc_html__(
                    'A valid base price type could not be retrieved from the database.',
                    'event_espresso'
                )
            );
        }
        $new_base_price->set('PRT_ID', $base_price_type->ID());
        $new_base_price->set('PRC_is_default', false);
        $new_base_price->save();
        $new_base_price->_add_relation_to($ticket, 'Ticket');
        return $new_base_price;
    }


    /**
     * @param array $prices
     * @return array
     * @throws EE_Error
     * @throws ReflectionException
     */
    private function separateTaxesFromOtherPrices(array $prices = []): array
    {
        $default_prices = [];
        if (is_array($prices)) {
            foreach ($prices as $key => $price) {
                if (! $price instanceof EE_Price) {
                    throw new InvalidEntityException($price, 'EE_Price');
                }
                // grab any taxes but don't do anything just yet
                if ($price->is_tax()) {
                    $this->taxes[ $price->ID() ] = $price;
                    continue;
                }
                $default_prices[ $price->ID() ] = $price;
            }
        }
        return $default_prices;
    }
}


1			<?php
2
3			namespace EventEspresso\core\domain\services\admin\entities;
4
5			use EE_Base_Class;
6			use EE_Error;
7			use EE_Price;
8			use EE_Price_Type;
9			use EE_Ticket;
10			use EEM_Price;
11			use EEM_Price_Type;
12			use EventEspresso\core\exceptions\InvalidEntityException;
13			use EventEspresso\core\exceptions\InvalidInterfaceException;
14			use ReflectionException;
15			use RuntimeException;
16
17			/**
18			* Class DefaultPrices
19			* Description
20			*
21			* @package EventEspresso\core\domain\services\admin\events\editor
22			* @author Brent Christensen
23			* @since $VID:$
24			*/
25			class DefaultPrices implements DefaultEntityGeneratorInterface
26			{
27
28			/**
29			* @var EEM_Price
30			*/
31			protected $price_model;
32
33			/**
34			* @var EEM_Price_Type
35			*/
36			protected $price_type_model;
37
38			/**
39			* @var EE_Price[]
40			*/
41			protected $new_prices = [];
42
43			/**
44			* @var EE_Price[]
45			*/
46			protected $taxes = [];
47
48
49			/**
50			* @param EEM_Price $price_model
51			* @param EEM_Price_Type $price_type_model
52			*/
53			public function __construct(EEM_Price $price_model, EEM_Price_Type $price_type_model)
54			{
55			$this->price_model = $price_model;
56			$this->price_type_model = $price_type_model;
57			}
58
59
60			/**
61			* @param EE_Ticket\|EE_Base_Class $entity
62			* @return EE_Price[]
63			* @throws EE_Error
64			* @throws InvalidInterfaceException
65			* @throws ReflectionException
66			* @since $VID:$
67			*/
68			public function create(EE_Base_Class $entity): array
69			{
70			if (! $entity instanceof EE_Ticket) {
71			throw new InvalidEntityException($entity, 'EE_Ticket');
72			}
73			$is_free = true;
74			$has_base_price = false;
75			$remove_existing_relations = true;
76			// first, let's get all of the default taxes for the site
77			$this->taxes = $this->price_model->getAllDefaultTaxes();
78			// then separate taxes from the other prices for the existing default ticket prices
79			$default_prices = $this->separateTaxesFromOtherPrices($entity->prices());
80			// but if that's empty, then let's get the default global prices
81			if (empty($default_prices)) {
82			$default_global_prices = $this->price_model->get_all_default_prices();
83			$default_prices = $this->separateTaxesFromOtherPrices($default_global_prices);
84			$remove_existing_relations = false;
85			}
86			// then clone and apply all of the default prices
87			[$has_base_price, $is_free] = $this->cloneDefaultPrices(
88			$entity,
89			$default_prices,
90			$remove_existing_relations,
91			$has_base_price,
92			$is_free
93			);
94			if (! $has_base_price) {
95			$new_base_price = $this->createNewBasePrice($entity);
96			$this->new_prices[ $new_base_price->ID() ] = $new_base_price;
97			}
98			$this->applyTaxes($entity, $is_free);
99			$ticket_total = $entity->get_ticket_total_with_taxes(true);
100			if ($ticket_total !== $entity->ticket_price()) {
101			$entity->set_price($ticket_total);
102			$entity->save();
103			}
104			return $this->new_prices;
105			}
106
107
108			/**
109			* @param EE_Ticket $ticket
110			* @param bool $is_free
111			* @throws EE_Error
112			* @throws ReflectionException
113			*/
114			private function applyTaxes(EE_Ticket $ticket, bool $is_free)
115			{
116			if (! $is_free && ! empty($this->taxes)) {
117			foreach ($this->taxes as $tax) {
118			// assign taxes but don't duplicate them because they operate globally
119			$ticket->set_taxable(true);
120			$tax->_add_relation_to($ticket, 'Ticket');
121			}
122			}
123			}
124
125
126			/**
127			* @param EE_Ticket $ticket
128			* @param EE_Price[] $default_prices
129			* @param bool $remove_existing_relations
130			* @param bool $has_base_price
131			* @param bool $is_free
132			* @return bool[]
133			* @throws EE_Error
134			* @throws ReflectionException
135			*/
136			private function cloneDefaultPrices(
137			EE_Ticket $ticket,
138			array $default_prices,
139			bool $remove_existing_relations,
140			bool $has_base_price,
141			bool $is_free
142			): array {
143			foreach ($default_prices as $default_price) {
144			// duplicate the default price so that it does not get mutated
145			$default_price_clone = clone $default_price;
146			if ($remove_existing_relations) {
147			$ticket->_remove_relation_to($default_price, 'Price');
148			}
149			if ((
150			// has non-zero base price
151			$default_price_clone->is_base_price()
152			&& $default_price_clone->amount() > 0
153			)
154			\|\| (
155			// or has fixed amount surcharge
156			$default_price_clone->is_surcharge()
157			&& ! $default_price_clone->is_percent()
158			)
159			) {
160			$is_free = false;
161			}
162			$is_base_price = $default_price_clone->is_base_price();
163			// add this price to ticket if it is a regular price modifier, ie: NOT a base price,
164			// OR if it IS a base price but this ticket does NOT already have a base price
165			if (! $is_base_price \|\| ! $has_base_price) {
166			$default_price_clone->set('PRC_ID', null);
167			$default_price_clone->set('PRC_is_default', false);
168			$default_price_clone->save();
169			$default_price_clone->_add_relation_to($ticket, 'Ticket');
170			$this->new_prices[ $default_price_clone->ID() ] = $default_price_clone;
171			// then recheck that a base price has been set so that we don't add another one
172			$has_base_price = $is_base_price ? true : $has_base_price;
173			}
174			}
175			return [$has_base_price, $is_free];
176			}
177
178
179			/**
180			* @param EE_Ticket $ticket
181			* @return EE_Price
182			* @throws EE_Error
183			* @throws ReflectionException
184			*/
185			private function createNewBasePrice(EE_Ticket $ticket): EE_Price
186			{
187			$new_base_price = $this->price_model->get_new_price();
188			$base_price_type = $this->price_type_model->get_one(
189			[
190			[
191			'PBT_ID' => EEM_Price_Type::base_type_base_price,
192			],
193			]
194			);
195			if (! $base_price_type instanceof EE_Price_Type) {
196			throw new RuntimeException(
197			esc_html__(
198			'A valid base price type could not be retrieved from the database.',
199			'event_espresso'
200			)
201			);
202			}
203			$new_base_price->set('PRT_ID', $base_price_type->ID());
204			$new_base_price->set('PRC_is_default', false);
205			$new_base_price->save();
206			$new_base_price->_add_relation_to($ticket, 'Ticket');
207			return $new_base_price;
208			}
209
210
211			/**
212			* @param array $prices
213			* @return array
214			* @throws EE_Error
215			* @throws ReflectionException
216			*/
217			private function separateTaxesFromOtherPrices(array $prices = []): array
218			{
219			$default_prices = [];
220			if (is_array($prices)) {
221			foreach ($prices as $key => $price) {
222			if (! $price instanceof EE_Price) {
223			throw new InvalidEntityException($price, 'EE_Price');
224			}
225			// grab any taxes but don't do anything just yet
226			if ($price->is_tax()) {
227			$this->taxes[ $price->ID() ] = $price;
228			continue;
229			}
230			$default_prices[ $price->ID() ] = $price;
231			}
232			}
233			return $default_prices;
234			}
235			}
236

eventespresso / event-espresso-core

Branch — dev (81ae86)

DefaultPrices::separateTaxesFromOtherPrices() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like