App\Http\Controllers\Customers\CustomerContactsController

Complexity

Total Complexity

15

Size/Duplication

Total Lines	154
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	destroy()	0	8	1
A	cleanPhoneNumber()	0	3	1
B	update()	0	55	6
A	restore()	0	8	1
A	store()	0	37	5
A	forceDelete()	0	8	1

<?php

namespace App\Http\Controllers\Customers;

use App\Http\Controllers\Controller;

use App\Models\Customer;
use App\Models\PhoneNumberType;
use App\Models\CustomerContact;
use App\Models\CustomerContactPhone;

use App\Http\Requests\Customers\CustomerContactsRequest;
use App\Events\Customers\Contacts\CustomerContactAddedEvent;
use App\Events\Customers\Contacts\CustomerContactDeletedEvent;
use App\Events\Customers\Contacts\CustomerContactForceDeletedEvent;
use App\Events\Customers\Contacts\CustomerContactRestoredEvent;
use App\Events\Customers\Contacts\CustomerContactUpdatedEvent;

class CustomerContactsController extends Controller
{
    /**
     * Store a newly created customer contact
     */
    public function store(CustomerContactsRequest $request)
    {
        $cust    = Customer::findOrFail($request->cust_id);
        $cust_id = $cust->cust_id;

        //  If the equipment is shared, it must be assigned to the parent site
        if($request->shared && $cust->parent_id > 0)
        {
            $cust_id = $cust->parent_id;
        }

        //  Create the contact
        $newContact = CustomerContact::create([
            'cust_id' => $cust_id,
            'name'    => $request->name,
            'email'   => $request->email,
            'shared'  => $request->shared,
            'title'   => $request->title,
            'note'    => $request->note,
        ]);

        //  Input the contacts phone numbers
        foreach($request->phones as $phone)
        {
            if(isset($phone['number']))
            {
                CustomerContactPhone::create([
                    'cont_id'       => $newContact->cont_id,
                    'phone_type_id' => PhoneNumberType::where('description', $phone['type'])->first()->phone_type_id,
                    'phone_number'  => $this->cleanPhoneNumber($phone['number']),
                    'extension'     => $phone['extension'],
                ]);
            }
        }

        event(new CustomerContactAddedEvent($cust, $newContact));
        return back()->with(['message' => 'New Contact Created', 'type' => 'success']);
    }

    /**
     * Update an existing contact
     */
    public function update(CustomerContactsRequest $request, $id)
    {
        $cust    = Customer::findOrFail($request->cust_id);
        $cust_id = $cust->cust_id;

        //  If the equipment is shared, it must be assigned to the parent site
        if($request->shared && $cust->parent_id > 0)
        {
            $cust_id = $cust->parent_id;
        }

        $contact = CustomerContact::find($id);
        $contact->update([
            'cust_id' => $cust_id,
            'name'    => $request->name,
            'email'   => $request->email,
            'shared'  => $request->shared,
            'title'   => $request->title,
            'note'    => $request->note,
        ]);

        $updatedNumbers = [];
        foreach($request->phones as $phone)
        {
            //  If the number is an existing number, update it
            if(isset($phone['id']))
            {
                CustomerContactPhone::find($phone['id'])->update([
                    'phone_type_id' => PhoneNumberType::where('description', $phone['phone_number_type']['description'])->first()->phone_type_id,
                    'phone_number'  => $this->cleanPhoneNumber($phone['phone_number']),
                    'extension'     => $phone['extension'],
                ]);
                $updatedNumbers[] = $phone['id'];
            }
            //  Otherwise enter a new number
            else
            {
                $new = CustomerContactPhone::create([
                    'cont_id'       => $id,
                    'phone_type_id' =>PhoneNumberType::where('description', $phone['phone_number_type']['description'])->first()->phone_type_id,
                    'phone_number'  => $this->cleanPhoneNumber($phone['phone_number']),
                    'extension'     => $phone['extension'],
                ]);
                $updatedNumbers[] = $new->id;
            }
        }

        $oldContacts = CustomerContactPhone::where('cont_id', $id)->whereNotIn('id', $updatedNumbers)->get();
        foreach($oldContacts as $cont)
        {
            $cont->delete();
        }

        event(new CustomerContactUpdatedEvent($cust, $contact));
        return back()->with(['message' => 'Contact Updated', 'type' => 'success']);
    }

    /**
     * Soft Delete a Customer Contact
     */
    public function destroy($id)
    {
        $this->authorize('delete', CustomerContact::class);
        $cont = CustomerContact::find($id);
        $cont->delete();

        event(new CustomerContactDeletedEvent(Customer::find($cont->cust_id), $cont));

It seems like App\Models\Customer::find($cont->cust_id) can also be of type null; however, parameter $cust of App\Events\Customers\Contacts\CustomerContactDeletedEvent::__construct() does only seem to accept App\Models\Customer, maybe add an additional type check?

It seems like $cont can also be of type null; however, parameter $cont of App\Events\Customers\Contacts\CustomerContactDeletedEvent::__construct() does only seem to accept App\Models\CustomerContact, maybe add an additional type check?

        return back()->with(['message' => 'Contact deleted', 'type' => 'danger']);
    }


    /**
     * Restore a contact that was soft deleted
     */
    public function restore($id)
    {
        $this->authorize('restore', CustomerContact::class);
        $cont = CustomerContact::withTrashed()->where('cont_id', $id)->first();
        $cont->restore();

        event(new CustomerContactRestoredEvent(Customer::find($cont->cust_id), $cont));

It seems like App\Models\Customer::find($cont->cust_id) can also be of type null; however, parameter $cust of App\Events\Customers\Contacts\CustomerContactRestoredEvent::__construct() does only seem to accept App\Models\Customer, maybe add an additional type check?

        return back()->with(['message' => 'Contact '.$cont->name.' restored', 'type' => 'success']);
    }

    /**
     * Permanently delete a contact
     */
    public function forceDelete($id)
    {
        $cont = CustomerContact::withTrashed()->where('cont_id', $id)->first();
        $this->authorize('forceDelete', $cont);
        $cont->forceDelete();

        event(new CustomerContactForceDeletedEvent(Customer::find($cont->cust_id), $cont));

It seems like App\Models\Customer::find($cont->cust_id) can also be of type null; however, parameter $cust of App\Events\Customers\Contacts\CustomerContactForceDeletedEvent::__construct() does only seem to accept App\Models\Customer, maybe add an additional type check?

        return back()->with(['message' => 'Contact permanently deleted', 'type' => 'danger']);
    }





    /*
    *   Clean the phone number to be digits only
    */
    protected function cleanPhoneNumber($number)
    {
        return preg_replace('~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4}).*~', '$1$2$3', $number);
    }
}