IPI::calcRetornoIsentoValorOutros() - Code Metrics - Inspection of "Implement on demand" - alaskasul/nfe-calculos - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 56ee19...663194 )

by João

created 2019-06-18 18:53 UTC

IPI::calcRetornoIsentoValorOutros() A

↳ Parent: IPI

Complexity

Conditions	4
Paths	2

Size

Total Lines	8
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	6
dl	0
loc	8
rs	10
c	0
b	0
f	0
cc	4
nc	2
nop	1

<?php

declare(strict_types=1);

namespace Gbbs\NfeCalculos;

use Exception;

class IPI
{
    public $descCST;
    public $clEnq;
    public $CodNCM;
    public $REIDE;
    public $SUFRAMA;
    public $CSTNotaRef;

    private $CNPJProd;
    private $cSelo;
    private $qSelo;
    private $cEnq;
    private $CST;
    private $vBC;
    private $pIPI;
    private $vIPI;
    private $qUnid;
    private $vUnid;

    /**
     * @param $IPI
     * @return mixed
     * @throws Exception
     */
    public static function calcular(IPI $IPI): void
    {
        if ($IPI->getCST() === '00') {
            /* ENTRADA COM RECUPERAÇÃO DE CRÉDITO */
            throw new Exception('Not implemented');
//            self::calcAliquotaAdValoren($IPI);
        } elseif ($IPI->getCST() === '01') {
            /* 01 ENTRADA TRIBUTADA COM ALICOTA ZERO */
            throw new Exception('Not implemented');
//            self::calcIsento($IPI);
        } elseif ($IPI->getCST() === '02') {
            /* ENTRADA ISENTA */
            throw new Exception('Not implemented');
//            self::calcIsento($IPI);
        } elseif ($IPI->getCST() === '03') {
            /* ENTRADA NÃO TRIBUTADA */
            throw new Exception('Not implemented');
//            self::calcIsento($IPI);
        } elseif ($IPI->getCST() === '04') {
            /* ENTRADA IMUNE */
            throw new Exception('Not implemented');
//            self::calcIsento($IPI);
        } elseif ($IPI->getCST() === '05') {
            /* ENTRADA COM SUSPENSAO */
            throw new Exception('Not implemented');
//            self::calcIsento($IPI);
        } elseif ($IPI->getCST() === '49') {
            /* OUTRAS ENTRADAS */
            throw new Exception('Not implemented');
//            self::calcRetornoIsentoValorOutros($IPI);
        } elseif ($IPI->getCST() === '50') {
            /* SAÍDA TRIBUTADA */
            self::calcAliquotaAdValoren($IPI);
        } elseif ($IPI->getCST() === '51') {
            /* SAÍDA TRIBUTADA COM ALICOTA ZERO */
            self::calcIsento($IPI);
        } elseif ($IPI->getCST() === '52') {
            /* SAÍDA ISENTA */
            throw new Exception('Not implemented');
//            self::calcIsento($IPI);
        } elseif ($IPI->getCST() === '53') {
            /* SAÍDA NÃO-TRIBUTADA */
            throw new Exception('Not implemented');
//            self::calcIsento($IPI);
        } elseif ($IPI->getCST() === '54') {
            /* SAÍDA IMUNE */
            throw new Exception('Not implemented');
//            self::calcIsento($IPI);
        } elseif ($IPI->getCST() === '55') {
            /* SAÍDA COM SUSPENSAO */
            throw new Exception('Not implemented');
//            self::calcIsento($IPI);
        } elseif ($IPI->getCST() === '99') {
            /* OUTRAS SAÍDAS */
            throw new Exception('Not implemented');
//            self::calcAliquotaAdValoren($IPI);
        } else {
            throw new Exception('Erro ao calcular IPI' . print_r($IPI, true));
        }
    }

    /**
     * ISENTO
     * @param $IPI
     */
    private static function calcIsento(self $IPI): void
    {
        $IPI->setVIPI(0.0);
        $IPI->setVBC(0.0);
        $IPI->setPIPI(0.0);
        $IPI->setQUnid(null);
        $IPI->setVUnid(null);
    }

    /**
     * Calcula o Valor IPI Ad Valoren
     * @param $IPI
     */
    private static function calcAliquotaAdValoren(self $IPI): void
    {
        $IPI->setVIPI($IPI->getVBC() * ($IPI->getPIPI() / 100));
    }

//    private static function calcRetornoIsentoValorOutros($IPI)
//    {
//        if ($IPI->CSTNotaRef === '00' || $IPI->CSTNotaRef === '50' || $IPI->CSTNotaRef === '99') {
//            $IPI->vIPI = ($IPI->vBC * ($IPI->pIPI / 100));
//            $IPI->pIPI = 0;
//        } else {
//            self::calcIsento($IPI);
//        }
//    }

    /**
     * @return string
     */
    public function getCNPJProd(): string
    {
        return $this->CNPJProd;
    }

    /**
     * @param string $CNPJProd
     */
    public function setCNPJProd(string $CNPJProd): void
    {
        $this->CNPJProd = $CNPJProd;
    }

    /**
     * @return string
     */
    public function getCSelo(): string
    {
        return $this->cSelo;
    }

    /**
     * @param string $cSelo
     */
    public function setCSelo(string $cSelo): void
    {
        $this->cSelo = $cSelo;
    }

    /**
     * @return float
     */
    public function getQSelo(): float
    {
        return $this->qSelo;
    }

    /**
     * @param float $qSelo
     */
    public function setQSelo(float $qSelo): void
    {
        $this->qSelo = $qSelo;
    }

    /**
     * @return string
     */
    public function getCEnq(): string
    {
        return $this->cEnq;
    }

    /**
     * @param string $cEnq
     */
    public function setCEnq(string $cEnq): void
    {
        $this->cEnq = $cEnq;
    }

    /**
     * @return string
     */
    public function getCST(): string
    {
        return $this->CST;
    }

    /**
     * @param string $CST
     */
    public function setCST(string $CST): void
    {
        $this->CST = $CST;
    }

    /**
     * @return float
     */
    public function getVBC(): float
    {
        return $this->vBC;
    }

    /**
     * @param float $vBC
     */
    public function setVBC(float $vBC): void
    {
        $this->vBC = $vBC;
    }

    /**
     * @return float
     */
    public function getPIPI(): float
    {
        return $this->pIPI;
    }

    /**
     * @param float $pIPI
     */
    public function setPIPI(float $pIPI): void
    {
        $this->pIPI = $pIPI;
    }

    /**
     * @return float
     */
    public function getVIPI(): float
    {
        return $this->vIPI;
    }

    /**
     * @param float $vIPI
     */
    public function setVIPI(float $vIPI): void
    {
        $this->vIPI = $vIPI;
    }

    /**
     * @return float
     */
    public function getQUnid(): float
    {
        return $this->qUnid;
    }

    /**
     * @param float $qUnid
     */
    public function setQUnid(?float $qUnid): void
    {
        $this->qUnid = $qUnid;
    }

    /**
     * @return float
     */
    public function getVUnid(): float
    {
        return $this->vUnid;
    }

    /**
     * @param float $vUnid
     */
    public function setVUnid(?float $vUnid): void
    {
        $this->vUnid = $vUnid;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Gbbs\NfeCalculos;
6
7			use Exception;
8
9			class IPI
10			{
11			public $descCST;
12			public $clEnq;
13			public $CodNCM;
14			public $REIDE;
15			public $SUFRAMA;
16			public $CSTNotaRef;
17
18			private $CNPJProd;
19			private $cSelo;
20			private $qSelo;
21			private $cEnq;
22			private $CST;
23			private $vBC;
24			private $pIPI;
25			private $vIPI;
26			private $qUnid;
27			private $vUnid;
28
29			/**
30			* @param $IPI
31			* @return mixed
32			* @throws Exception
33			*/
34			public static function calcular(IPI $IPI): void
35			{
36			if ($IPI->getCST() === '00') {
37			/* ENTRADA COM RECUPERAÇÃO DE CRÉDITO */
38			throw new Exception('Not implemented');
39			// self::calcAliquotaAdValoren($IPI);
40			} elseif ($IPI->getCST() === '01') {
41			/* 01 ENTRADA TRIBUTADA COM ALICOTA ZERO */
42			throw new Exception('Not implemented');
43			// self::calcIsento($IPI);
44			} elseif ($IPI->getCST() === '02') {
45			/* ENTRADA ISENTA */
46			throw new Exception('Not implemented');
47			// self::calcIsento($IPI);
48			} elseif ($IPI->getCST() === '03') {
49			/* ENTRADA NÃO TRIBUTADA */
50			throw new Exception('Not implemented');
51			// self::calcIsento($IPI);
52			} elseif ($IPI->getCST() === '04') {
53			/* ENTRADA IMUNE */
54			throw new Exception('Not implemented');
55			// self::calcIsento($IPI);
56			} elseif ($IPI->getCST() === '05') {
57			/* ENTRADA COM SUSPENSAO */
58			throw new Exception('Not implemented');
59			// self::calcIsento($IPI);
60			} elseif ($IPI->getCST() === '49') {
61			/* OUTRAS ENTRADAS */
62			throw new Exception('Not implemented');
63			// self::calcRetornoIsentoValorOutros($IPI);
64			} elseif ($IPI->getCST() === '50') {
65			/* SAÍDA TRIBUTADA */
66			self::calcAliquotaAdValoren($IPI);
67			} elseif ($IPI->getCST() === '51') {
68			/* SAÍDA TRIBUTADA COM ALICOTA ZERO */
69			self::calcIsento($IPI);
70			} elseif ($IPI->getCST() === '52') {
71			/* SAÍDA ISENTA */
72			throw new Exception('Not implemented');
73			// self::calcIsento($IPI);
74			} elseif ($IPI->getCST() === '53') {
75			/* SAÍDA NÃO-TRIBUTADA */
76			throw new Exception('Not implemented');
77			// self::calcIsento($IPI);
78			} elseif ($IPI->getCST() === '54') {
79			/* SAÍDA IMUNE */
80			throw new Exception('Not implemented');
81			// self::calcIsento($IPI);
82			} elseif ($IPI->getCST() === '55') {
83			/* SAÍDA COM SUSPENSAO */
84			throw new Exception('Not implemented');
85			// self::calcIsento($IPI);
86			} elseif ($IPI->getCST() === '99') {
87			/* OUTRAS SAÍDAS */
88			throw new Exception('Not implemented');
89			// self::calcAliquotaAdValoren($IPI);
90			} else {
91			throw new Exception('Erro ao calcular IPI' . print_r($IPI, true));
92			}
93			}
94
95			/**
96			* ISENTO
97			* @param $IPI
98			*/
99			private static function calcIsento(self $IPI): void
100			{
101			$IPI->setVIPI(0.0);
102			$IPI->setVBC(0.0);
103			$IPI->setPIPI(0.0);
104			$IPI->setQUnid(null);
105			$IPI->setVUnid(null);
106			}
107
108			/**
109			* Calcula o Valor IPI Ad Valoren
110			* @param $IPI
111			*/
112			private static function calcAliquotaAdValoren(self $IPI): void
113			{
114			$IPI->setVIPI($IPI->getVBC() * ($IPI->getPIPI() / 100));
115			}
116
117			// private static function calcRetornoIsentoValorOutros($IPI)
118			// {
119			// if ($IPI->CSTNotaRef === '00' \|\| $IPI->CSTNotaRef === '50' \|\| $IPI->CSTNotaRef === '99') {
120			// $IPI->vIPI = ($IPI->vBC * ($IPI->pIPI / 100));
121			// $IPI->pIPI = 0;
122			// } else {
123			// self::calcIsento($IPI);
124			// }
125			// }
126
127			/**
128			* @return string
129			*/
130			public function getCNPJProd(): string
131			{
132			return $this->CNPJProd;
133			}
134
135			/**
136			* @param string $CNPJProd
137			*/
138			public function setCNPJProd(string $CNPJProd): void
139			{
140			$this->CNPJProd = $CNPJProd;
141			}
142
143			/**
144			* @return string
145			*/
146			public function getCSelo(): string
147			{
148			return $this->cSelo;
149			}
150
151			/**
152			* @param string $cSelo
153			*/
154			public function setCSelo(string $cSelo): void
155			{
156			$this->cSelo = $cSelo;
157			}
158
159			/**
160			* @return float
161			*/
162			public function getQSelo(): float
163			{
164			return $this->qSelo;
165			}
166
167			/**
168			* @param float $qSelo
169			*/
170			public function setQSelo(float $qSelo): void
171			{
172			$this->qSelo = $qSelo;
173			}
174
175			/**
176			* @return string
177			*/
178			public function getCEnq(): string
179			{
180			return $this->cEnq;
181			}
182
183			/**
184			* @param string $cEnq
185			*/
186			public function setCEnq(string $cEnq): void
187			{
188			$this->cEnq = $cEnq;
189			}
190
191			/**
192			* @return string
193			*/
194			public function getCST(): string
195			{
196			return $this->CST;
197			}
198
199			/**
200			* @param string $CST
201			*/
202			public function setCST(string $CST): void
203			{
204			$this->CST = $CST;
205			}
206
207			/**
208			* @return float
209			*/
210			public function getVBC(): float
211			{
212			return $this->vBC;
213			}
214
215			/**
216			* @param float $vBC
217			*/
218			public function setVBC(float $vBC): void
219			{
220			$this->vBC = $vBC;
221			}
222
223			/**
224			* @return float
225			*/
226			public function getPIPI(): float
227			{
228			return $this->pIPI;
229			}
230
231			/**
232			* @param float $pIPI
233			*/
234			public function setPIPI(float $pIPI): void
235			{
236			$this->pIPI = $pIPI;
237			}
238
239			/**
240			* @return float
241			*/
242			public function getVIPI(): float
243			{
244			return $this->vIPI;
245			}
246
247			/**
248			* @param float $vIPI
249			*/
250			public function setVIPI(float $vIPI): void
251			{
252			$this->vIPI = $vIPI;
253			}
254
255			/**
256			* @return float
257			*/
258			public function getQUnid(): float
259			{
260			return $this->qUnid;
261			}
262
263			/**
264			* @param float $qUnid
265			*/
266			public function setQUnid(?float $qUnid): void
267			{
268			$this->qUnid = $qUnid;
269			}
270
271			/**
272			* @return float
273			*/
274			public function getVUnid(): float
275			{
276			return $this->vUnid;
277			}
278
279			/**
280			* @param float $vUnid
281			*/
282			public function setVUnid(?float $vUnid): void
283			{
284			$this->vUnid = $vUnid;
285			}
286			}
287

alaskasul / nfe-calculos

Push — master ( 56ee19...663194 )

IPI::calcRetornoIsentoValorOutros() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like