App\Http\Controllers\ProfilesController

Complexity

Total Complexity

36

Size/Duplication

Total Lines	488
Duplicated Lines	0 %

Importance

Changes	6
Bugs	1	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	userProfileAvatar()	0	3	1
A	account()	0	10	1
A	getIdMultiKey()	0	3	1
A	upload()	0	23	2
A	__construct()	0	3	1
A	sendGoodbyEmail()	0	3	1
A	getSeperationKey()	0	3	1
A	deleteUserAccount()	0	52	3
A	uploadBackground()	0	24	2
A	userProfileBackgroundImage()	0	3	1
A	validator()	0	4	1
B	update()	0	59	7
A	updateUserPassword()	0	33	3
A	profile_validator()	0	12	1
A	show()	0	16	2
A	getUserByUsername()	0	3	1
A	updateUserAccount()	0	40	5
A	edit()	0	24	2

<?php

namespace App\Http\Controllers;

use App\Models\Profile;
use App\Models\Theme;
use App\Models\User;
use App\Notifications\SendGoodbyeEmail;
use App\Traits\CaptureIpTrait;
use File;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;
use Illuminate\Support\Facades\Session;
use Image;
use Validator;
use View;
use Webpatser\Uuid\Uuid;

class ProfilesController extends Controller
{
    protected $idMultiKey = '618423'; //int
    protected $seperationKey = '****';

    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('auth');
    }

    /**
     * Get a validator for an incoming registration request.
     *
     * @param array $data
     *
     * @return \Illuminate\Contracts\Validation\Validator
     */
    public function profile_validator(array $data)
    {
        return Validator::make($data, [
            'first_name'        => 'nullable|alpha',
            'last_name'         => 'nullable|alpha',
            'theme_id'          => 'required',
            'location'          => 'nullable',
            'bio'               => 'nullable|max:500',
            'twitter_username'  => 'nullable|max:50',
            'github_username'   => 'nullable|max:50',
            'avatar'            => '',
            'avatar_status'     => '',
        ]);
    }

    /**
     * Get a validator for an incoming update user request.
     *
     * @param array $data
     *
     * @return \Illuminate\Contracts\Validation\Validator
     */
    public function validator(array $data)
    {
        return Validator::make($data, [
            'name'              => 'required|max:255',
        ]);
    }

    /**
     * Fetch user
     * (You can extract this to repository method).
     *
     * @param $username
     *
     * @return mixed
     */
    public function getUserByUsername($username)
    {
        return User::with('profile')->wherename($username)->firstOrFail();
    }

    /**
     * Display the specified resource.
     *
     * @param string $username
     *
     * @return Response

The type App\Http\Controllers\Response was not found. Did you mean Response? If so, make sure to prefix the type with \.

     */
    public function show($username)
    {
        try {
            $user = $this->getUserByUsername($username);
        } catch (ModelNotFoundException $exception) {
            abort(404);
        }

        $currentTheme = Theme::find($user->profile->theme_id);

        $data = [
            'user'         => $user,
            'currentTheme' => $currentTheme,
        ];

        return view('profiles.show')->with($data);

The expression return view('profiles.show')->with($data) returns the type Illuminate\View\View which is incompatible with the documented return type App\Http\Controllers\Response.

    }

    /**
     * /profiles/username/edit.
     *
     * @param $username
     *
     * @return mixed
     */
    public function edit($username)
    {
        try {
            $user = $this->getUserByUsername($username);
        } catch (ModelNotFoundException $exception) {
            return view('pages.status')
                ->with('error', trans('profile.notYourProfile'))
                ->with('error_title', trans('profile.notYourProfileTitle'));
        }

        $themes = Theme::where('status', 1)
                       ->orderBy('name', 'asc')
                       ->get();

        $currentTheme = Theme::find($user->profile->theme_id);

        $data = [
            'user'          => $user,
            'themes'        => $themes,
            'currentTheme'  => $currentTheme,

        ];

        return view('profiles.edit')->with($data);
    }

    /**
     * Update a user's profile.
     *
     * @param $username
     *
     * @throws Laracasts\Validation\FormValidationException
     *
     * @return mixed
     */
    public function update($username, Request $request)
    {
        $data = $request->formData;
        $info = [];
        foreach ($data as $key => $value) {
            $info[] = [
                $value['name'] => $value['value'],
            ];
        }
        $convertedData = call_user_func_array('array_merge', $info);

        $user = $this->getUserByUsername($username);
        $ipAddress = new CaptureIpTrait();

        if ($request->ajax()) {
            $profile_validator = $this->profile_validator($convertedData);
        } else {
            $profile_validator = $this->profile_validator($request->all());
            $input = $request->all();
        }

        if ($profile_validator->fails()) {
            $this->throwValidationException(

The method throwValidationException() does not exist on App\Http\Controllers\ProfilesController. Since you implemented __call, consider adding a @method annotation.

                $request, $profile_validator
            );

            return redirect('profile/'.$user->name.'/edit')->withErrors($validator)->withInput();

The variable $validator does not exist. Did you maybe mean $profile_validator?

        }

        if ($user->profile == null) {
            $profile = new Profile();
            $profile->fill($input);

The variable $input does not seem to be defined for all execution paths leading up to this point.

            $user->profile()->save($profile);
        } else {
            if ($request->ajax()) {
                $user->profile->fill($convertedData)->save();
                $user->fill($convertedData);
            } else {
                $user->profile->fill($input)->save();
                $user->fill($input);
            }
        }

        $user->updated_ip_address = $ipAddress->getClientIp();
        $user->save();

        if ($request->ajax()) {
            $theme = Theme::find($user->profile->theme_id);

            $returnData = [
                'title'     => trans('auth.success'),
                'message'   => trans('profile.updateSuccess'),
                'themeLink' => $theme->link,
            ];

            return response()->json($returnData, 200);
        }

        return redirect('profile/'.$user->name.'/edit')->with('success', trans('profile.updateSuccess'));
    }

    /**
     * User account admin page.
     *
     * @return \Illuminate\Http\Response
     */
    public function account()
    {
        $user = \Auth::user();
        $username = $user->name;

The assignment to $username is dead and can be removed.

Accessing name on the interface Illuminate\Contracts\Auth\Authenticatable suggest that you code against a concrete implementation. How about adding an instanceof check?

        $data = [
            'user' => $user,
        ];

        return view('profiles.account')->with($data);

The expression return view('profiles.account')->with($data) returns the type Illuminate\View\View which is incompatible with the documented return type Illuminate\Http\Response.

    }

    /**
     * Update the specified resource in storage.
     *
     * @param \Illuminate\Http\Request $request
     * @param int                      $id
     *
     * @return \Illuminate\Http\Response
     */
    public function updateUserAccount(Request $request, $id)
    {
        $currentUser = \Auth::user();

The assignment to $currentUser is dead and can be removed.

        $user = User::findOrFail($id);
        $emailCheck = ($request->input('email') != '') && ($request->input('email') != $user->email);
        $ipAddress = new CaptureIpTrait();

        $validator = Validator::make($request->all(), [

The assignment to $validator is dead and can be removed.

            'name'      => 'required|max:255',
        ]);

        $rules = [];

        if ($emailCheck) {
            $rules = [
                'email'     => 'email|max:255|unique:users',
            ];
        }

        $validator = $this->validator($request->all(), $rules);

The call to App\Http\Controllers\ProfilesController::validator() has too many arguments starting with $rules.

        if ($validator->fails()) {
            $this->throwValidationException(
                $request, $validator
            );
        }

        $user->name = $request->input('name');
        $user->first_name = $request->input('first_name');
        $user->last_name = $request->input('last_name');

        if ($emailCheck) {
            $user->email = $request->input('email');
        }

        $user->updated_ip_address = $ipAddress->getClientIp();

        $user->save();

        return redirect('profile/'.$user->name.'/edit')->with('success', trans('profile.updateAccountSuccess'));

The expression return redirect('profile/' . $user->name . '/edit')->with('success', trans('profile.updateAccountSuccess')) returns the type Illuminate\Http\RedirectResponse which is incompatible with the documented return type Illuminate\Http\Response.

    }

    /**
     * Update the specified resource in storage.
     *
     * @param \Illuminate\Http\Request $request
     * @param int                      $id
     *
     * @return \Illuminate\Http\Response
     */
    public function updateUserPassword(Request $request, $id)
    {
        $currentUser = \Auth::user();

The assignment to $currentUser is dead and can be removed.

        $user = User::findOrFail($id);
        $ipAddress = new CaptureIpTrait();

        $validator = Validator::make($request->all(),
            [
                'password'              => 'required|min:6|max:20|confirmed',
                'password_confirmation' => 'required|same:password',
            ],
            [
                'password.required'     => trans('auth.passwordRequired'),
                'password.min'          => trans('auth.PasswordMin'),
                'password.max'          => trans('auth.PasswordMax'),
            ]
        );

        if ($validator->fails()) {
            $this->throwValidationException(
                $request, $validator
            );
        }

        if ($request->input('password') != null) {
            $user->password = bcrypt($request->input('password'));
        }

        $user->updated_ip_address = $ipAddress->getClientIp();

        $user->save();

        return redirect('profile/'.$user->name.'/edit')->with('success', trans('profile.updatePWSuccess'));

The expression return redirect('profile/' . $user->name . '/edit')->with('success', trans('profile.updatePWSuccess')) returns the type Illuminate\Http\RedirectResponse which is incompatible with the documented return type Illuminate\Http\Response.

    }

    /**
     * Upload and Update user avatar.
     *
     * @param $file
     *
     * @return mixed
     */
    public function upload()
    {
        if (Input::hasFile('file')) {
            $currentUser = \Auth::user();
            $avatar = Input::file('file');
            $filename = 'avatar.'.$avatar->getClientOriginalExtension();
            $save_path = storage_path().'/users/id/'.$currentUser->id.'/uploads/images/avatar/';

Accessing id on the interface Illuminate\Contracts\Auth\Authenticatable suggest that you code against a concrete implementation. How about adding an instanceof check?

            $path = $save_path.$filename;
            $public_path = '/images/profile/'.$currentUser->id.'/avatar/'.$filename;

            // Make the user a folder and set permissions
            File::makeDirectory($save_path, $mode = 0755, true, true);

            // Save the file to the server
            Image::make($avatar)->resize(300, 300)->save($save_path.$filename);

            // Save the public image path
            $currentUser->profile->avatar = $public_path;

Accessing profile on the interface Illuminate\Contracts\Auth\Authenticatable suggest that you code against a concrete implementation. How about adding an instanceof check?

            $currentUser->profile->save();

            return response()->json(['path'=> $path], 200);
        } else {
            return response()->json(false, 200);
        }
    }

    /**
     * Upload and update the user profile background.
     *
     * @param $file
     *
     * @return mixed
     */
    public function uploadBackground()
    {
        if (Input::hasFile('file')) {
            $currentUser = \Auth::user();
            $user_profile_bg = Input::file('file');
            $filename = 'background.'.$user_profile_bg->getClientOriginalExtension();
            $save_path = storage_path().'/users/id/'.$currentUser->id.'/uploads/images/background/';

Accessing id on the interface Illuminate\Contracts\Auth\Authenticatable suggest that you code against a concrete implementation. How about adding an instanceof check?

            $path = $save_path.$filename;
            $public_path = '/images/profile/'.$currentUser->id.'/background/'.$filename;

            // Make the user a folder and set permissions
            File::makeDirectory($save_path, $mode = 0755, true, true);

            // Save the file to the server
            // Image::make($user_profile_bg)->resize(300, 300)->save($save_path . $filename);
            Image::make($user_profile_bg)->save($save_path.$filename);

            // Save the public image path
            $currentUser->profile->user_profile_bg = $public_path;

Accessing profile on the interface Illuminate\Contracts\Auth\Authenticatable suggest that you code against a concrete implementation. How about adding an instanceof check?

            $currentUser->profile->save();

            return response()->json(['path'=> $path], 200);
        } else {
            return response()->json(false, 200);
        }
    }

    /**
     * Show user avatar.
     *
     * @param $id
     * @param $image
     *
     * @return string
     */
    public function userProfileAvatar($id, $image)
    {
        return Image::make(storage_path().'/users/id/'.$id.'/uploads/images/avatar/'.$image)->response();
    }

    /**
     * Show user background image.
     *
     * @param $id
     * @param $image
     *
     * @return string
     */
    public function userProfileBackgroundImage($id, $image)
    {
        return Image::make(storage_path().'/users/id/'.$id.'/uploads/images/background/'.$image)->response();
    }

    /**
     * Update the specified resource in storage.
     *
     * @param \Illuminate\Http\Request $request
     * @param int                      $id
     *
     * @return \Illuminate\Http\Response
     */
    public function deleteUserAccount(Request $request, $id)
    {
        $currentUser = \Auth::user();
        $user = User::findOrFail($id);
        $ipAddress = new CaptureIpTrait();

        $validator = Validator::make($request->all(),
            [
                'checkConfirmDelete'            => 'required',
            ],
            [
                'checkConfirmDelete.required'   => trans('profile.confirmDeleteRequired'),
            ]
        );

        if ($validator->fails()) {
            $this->throwValidationException(
                $request, $validator
            );
        }

        if ($user->id != $currentUser->id) {

Accessing id on the interface Illuminate\Contracts\Auth\Authenticatable suggest that you code against a concrete implementation. How about adding an instanceof check?

            return redirect('profile/'.$user->name.'/edit')->with('error', trans('profile.errorDeleteNotYour'));

The expression return redirect('profile/' . $user->name . '/edit')->with('error', trans('profile.errorDeleteNotYour')) returns the type Illuminate\Http\RedirectResponse which is incompatible with the documented return type Illuminate\Http\Response.

        }

        // Create and encrypt user account restore token
        $sepKey = $this->getSeperationKey();
        $userIdKey = $this->getIdMultiKey();
        $restoreKey = config('settings.restoreKey');
        $encrypter = config('settings.restoreUserEncType');
        $level1 = $user->id * $userIdKey;
        $level2 = urlencode(Uuid::generate(4).$sepKey.$level1);
        $level3 = base64_encode($level2);
        $level4 = openssl_encrypt($level3, $encrypter, $restoreKey);
        $level5 = base64_encode($level4);

        // Save Restore Token and Ip Address
        $user->token = $level5;
        $user->deleted_ip_address = $ipAddress->getClientIp();
        $user->save();

        // Send Goodbye email notification
        $this->sendGoodbyEmail($user, $user->token);

        // Soft Delete User
        $user->delete();

        // Clear out the session
        $request->session()->flush();
        $request->session()->regenerate();

        return redirect('/login/')->with('success', trans('profile.successUserAccountDeleted'));

The expression return redirect('/login/')->with('success', trans('profile.successUserAccountDeleted')) returns the type Illuminate\Http\RedirectResponse which is incompatible with the documented return type Illuminate\Http\Response.

    }

    /**
     * Send GoodBye Email Function via Notify.
     *
     * @param array  $user
     * @param string $token
     *
     * @return void
     */
    public static function sendGoodbyEmail(User $user, $token)
    {
        $user->notify(new SendGoodbyeEmail($token));
    }

    /**
     * Get User Restore ID Multiplication Key.
     *
     * @return string
     */
    public function getIdMultiKey()
    {
        return $this->idMultiKey;
    }

    /**
     * Get User Restore Seperation Key.
     *
     * @return string
     */
    public function getSeperationKey()
    {
        return $this->seperationKey;
    }
}