Epmnzava\BillMe\BillMe

Complexity

Total Complexity

18

Size/Duplication

Total Lines	229
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	createOrder()	0	52	4
A	add_billing_record()	0	14	1
A	sendMailNotifications()	0	6	1
A	createInvoice()	0	22	1
A	getInvoiceByOrderId()	0	4	1
A	getInvoiceByInvoiceId()	0	5	1
A	getOrderByOrderId()	0	4	1
A	getOrderByInvoiceId()	0	4	1
A	update_invoice_status()	0	6	1
A	update_invoice()	0	3	1
A	update_order_status()	0	6	1
A	update_order()	0	3	1
A	cancel_order()	0	6	1
A	delete_order()	0	7	1
A	delete_invoice()	0	5	1

<?php

/**
 * Author: Emmanuel Paul Mnzava
 * Twitter: @epmnzava
 * Github: https://github.com/dbrax/bill-me
 * Email: epmnzava@gmail.com
 * 
 */

namespace Epmnzava\BillMe;

use Epmnzava\BillMe\Models\Order;
use Epmnzava\BillMe\Models\Invoice;
use Epmnzava\BillMe\Models\OrderItem;
use Epmnzava\BillMe\Mail\Client\Invoices\InvoiceCreated;
use Epmnzava\BillMe\Mail\Client\OrderReceived;
use Epmnzava\BillMe\Mail\Merchant\NewOrder;
use Carbon\Carbon;
use Epmnzava\BillMe\Models\BillingPayment;
use Mail;

class BillMe extends Queries
{



    /** 
     * A function that triggers order creation
     * 
     */
    public function createOrder(
        int $userid = null,
        string $firstname,
        string $lastname,
        string $email,
        string $mobile_number,
        int $amount,
        string $payment_method,
        string $notes,
        string $address,
        array $orderitems
    ): Order {

        $order = new Order;
        $order->userid = $userid;
        $order->firstname = $firstname;
        $order->lastname = $lastname;
        $order->email = $email;
        $order->mobile_number = $mobile_number;
        $order->amount = $amount;
        $order->payment_method = $payment_method;
        $order->status = "pending";
        $order->notes = $notes;
        $order->address = $address;
        $order->date = date("Y-m-d");

        $order->save();

        // Loop through order items here
        if (!empty($orderitems)) {

            for ($i = 0; $i < count($orderitems); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

                $orderItem = new OrderItem();
                $orderItem->order_id = $order->id;
                $orderItem->amount = $orderitems[$i]->amount;
                $orderItem->quantity = $orderitems[$i]->quantity;
                $orderItem->item = $orderitems[$i]->item;
                $orderItem->extra_details = serialize($orderitems[$i]->extra_details);
                $orderItem->save();
            }
        }


        $invoice = $this->createInvoice($order);

        if (config('bill-me.send_mail') == 1)
            $this->sendMailNotifications($order, $invoice);

        $billing_record = $this->add_billing_record($order, $invoice);

$billing_record is not used, you could remove the assignment.

        return $order;
    }



    public function add_billing_record(Order $order, Invoice $invoice)
    {

        $bill_payment = new BillingPayment;
        $bill_payment->userid = $order->userid;
        $bill_payment->invoiceid = $invoice->id;
        $bill_payment->orderid = $order->id;
        $bill_payment->amount = $invoice->amount;
        $bill_payment->date = $order->date;
        $bill_payment->save();


        return $bill_payment;
    }


    /**
     * Function that triggers sending of email notification for orders
     */

    public function sendMailNotifications(Order $order, Invoice $invoice)
    {
        Mail::to(["email" => $order->email, "name" => $order->email])->send(new OrderReceived($order));
        Mail::to(["email" => $order->email, "name" => $order->email])->send(new NewOrder($order));
        Mail::to(["address" => $invoice->email, "name" => $invoice->email])->send(new InvoiceCreated($invoice));
    }



    /**
     * Function that creates an invoie from an order
     */

    public function createInvoice(Order $order): Invoice
    {

        $invoice = new Invoice;
        $invoice->orderid = $order->id;
        $invoice->userid = $order->userid;
        $invoice->firstname = $order->firstname;
        $invoice->lastname = $order->lastname;
        $invoice->mobile_number = $order->mobile_number;
        $invoice->email = $order->email;
        $invoice->amount = $order->amount;
        $invoice->status = $order->status;
        $invoice->address = $order->address;
        $invoice->date = date('Y-m-d');
        $invoice->save();

        $order_update = Order::find($order->id);
        $order_update->invoiceid = $invoice->id;
        $order_update->save();

        return $invoice;
    }


    /**
     * Function that gets you invoice details by using orderid
     */

    public function getInvoiceByOrderId($orderid)
    {
        return Invoice::where('orderid', $orderid)->first();
    }

    /**
     * Function that gets you invoice details by using invoiceid
     */

    public function getInvoiceByInvoiceId($invoiceid)
    {

        return Invoice::find($invoiceid);
    }



    /**
     * Function that gets you order details by using orderid
     */

    public function getOrderByOrderId($orderid)
    {
        return Order::find($orderid);
    }

    /**
     * Function that gets you order details by using invoiceid
     */

    public function getOrderByInvoiceId($invoiceid)
    {
        return Order::find(Invoice::where('id', $invoiceid)->first()->orderid);
    }


    /**
     * Function that updates invoice status and returns void
     */
    public function update_invoice_status(string $invoiceid, string $status): void
    {
        $invoice = Invoice::find($invoiceid);
        $invoice->status = $status;
        $invoice->save();
    }


    public function update_invoice(string $invoiceid, Invoice $invoice): void

The parameter $invoiceid is not used and could be removed.

The parameter $invoice is not used and could be removed.

    {
    }




    /**
     * Function that updates order status and returns void
     */
    public function update_order_status(string $orderid, string $status): void
    {
        $order = Order::find($orderid);
        $order->status = $status;
        $order->save();
    }


    /**
     * Function that updates an  order  returns void
     */
    public function update_order(string $order_id, Order $order): void

The parameter $order_id is not used and could be removed.

The parameter $order is not used and could be removed.

    {
    }


    /**
     * Function that updates and  status to cancelled  returns void
     */
    public function cancel_order(string $orderid): void
    {
        $order = Order::find($orderid);
        $order->status = "cancelled";
        $order->save();
    }


    /**
     * Function that deletes an order returns void
     */
    public function delete_order(string $orderid)
    {

        $order = Order::find($orderid);
        $order->delete();
        $this->delete_invoice($orderid);
    }

    /**
     * Function that deletes an invoice returns void
     */
    public function delete_invoice(string $orderid): void
    {

        $invoice = Invoice::where('orderid', $orderid)->delete();

$invoice is not used, you could remove the assignment.

    }
}