App\Services\UserService

Complexity

Total Complexity

44

Size/Duplication

Total Lines	643
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	validateTokenLoginRequest()	0	11	1
A	validateLoginRequest()	0	15	1
A	validateGoogleLoginRequest()	0	13	1
A	generateLoginData()	0	14	2
A	generateRememberMeToken()	0	12	1
A	loginUserWithRememberToken()	0	11	1
A	validateRegisterRequest()	0	23	1
A	validateResendActivationCodeRequest()	0	12	1
A	registerUser()	0	17	1
A	resendRegisterMail()	0	25	4
A	updateRememberTokenValability()	0	10	2
A	validateUpdateUserPictureRequest()	0	12	1
A	updateLoggedUserPicture()	0	28	6
A	activateUserAccount()	0	17	2
A	validateChangePasswordRequest()	0	22	1
A	updateLoggedUser()	0	28	4
A	getUserBuilderForLogin()	0	6	1
A	validateForgotPasswordRequest()	0	13	1
A	loginUserWithSocial()	0	39	4
A	sendForgotPasswordCode()	0	10	1
A	updatePassword()	0	7	1
A	validateActivateAccountOrChangeEmailRequest()	0	14	1
A	validateFacebookLoginRequest()	0	13	1
A	loginUser()	0	19	3
A	validateUpdateUserRequest()	0	26	1

<?php

namespace App\Services;

use App\Constants\TranslationCode;
use App\Models\Language;
use App\Models\Role;
use App\Models\User;
use App\Models\UserToken;
use Carbon\Carbon;
use Illuminate\Contracts\Validation\Validator as ReturnedValidator;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;
use IonGhitun\JwtToken\Jwt;
use IonGhitun\MysqlEncryption\Models\BaseModel;
use Laravel\Socialite\Two\User as SocialiteUser;

/**
 * Class UserService
 *
 * @package App\Services
 */
class UserService
{
    /**
     * Validate request on login
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateLoginRequest(Request $request)
    {
        $rules = [
            'email'    => 'required|email|exists_encrypted:users,email',
            'password' => 'required'
        ];

        $messages = [
            'email.required'         => TranslationCode::ERROR_EMAIL_REQUIRED,
            'email.email'            => TranslationCode::ERROR_EMAIL_INVALID,
            'email.exists_encrypted' => TranslationCode::ERROR_EMAIL_NOT_REGISTERED,
            'password.required'      => TranslationCode::ERROR_PASSWORD_REQUIRED
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Validate request on login with remember token
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateTokenLoginRequest(Request $request)
    {
        $rules = [
            'rememberToken' => 'required'
        ];

        $messages = [
            'rememberToken.required' => TranslationCode::ERROR_REMEMBER_TOKEN_REQUIRED
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Get user from email and password
     *
     * @param  array  $credentials
     *
     * @return User|null
     */
    public function loginUser(array $credentials)
    {
        $builder = self::getUserBuilderForLogin();

        /** @var User|null $user */
        $user = $builder->whereEncrypted('email', $credentials['email'])
                        ->first();

        if (!$user) {
            return null;
        }

        $password = $user->password;

        if (app('hash')->check($credentials['password'], $password)) {
            return $user;
        }

        return null;
    }

    /**
     * Get user builder for login
     *
     * @return Builder|BaseModel
     */
    public static function getUserBuilderForLogin()
    {
        return User::with([
            'role' => function ($query) {
                $query->select(['id', 'name'])
                      ->with(['permissions']);
            }
        ]);
    }

    /**
     * Generate returned data on login
     *
     * @param  User  $user
     * @param  bool  $remember
     *
     * @return array
     */
    public function generateLoginData(User $user, $remember = false)
    {
        $data = [
            'user'  => $user,
            'token' => Jwt::generateToken([
                'id' => $user->id
            ])
        ];

        if ($remember) {
            $data['rememberToken'] = $this->generateRememberMeToken($user->id);
        }

        return $data;
    }

    /**
     * Generate remember me token
     *
     * @param $userId
     * @param $days
     *
     * @return string
     */
    public function generateRememberMeToken($userId, $days = 14)
    {
        $userToken = new UserToken();

        $userToken->user_id   = $userId;
        $userToken->token     = Str::random(64);
        $userToken->type      = UserToken::TYPE_REMEMBER_ME;
        $userToken->expire_on = Carbon::now()->addDays($days)->format('Y-m-d H:i:s');

        $userToken->save();

        return $userToken->token;
    }

    /**
     * Login user with remembered token
     *
     * @param $token
     *
     * @return User|null
     */
    public function loginUserWithRememberToken($token)
    {
        $builder = self::getUserBuilderForLogin();

        /** @var User|null $user */
        $user = $builder->whereHas('userTokens', function ($query) use ($token) {
            $query->where('token', $token)
                  ->where('expire_on', '>=', Carbon::now()->format('Y-m-d H:i:s'));
        })->first();

        return $user;
    }

    /**
     * Update remember token validity when used on login
     *
     * @param $token
     * @param  int  $days
     */
    public function updateRememberTokenValability($token, $days = 14)
    {
        $userToken = UserToken::where('token', $token)
                              ->where('type', UserToken::TYPE_REMEMBER_ME)
                              ->first();

        if ($userToken) {
            $userToken->expire_on = Carbon::now()->addDays($days)->format('Y-m-d H:i:s');

            $userToken->save();
        }
    }

    /**
     * Validate request on facebook login
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateFacebookLoginRequest(Request $request)
    {
        $rules = [
            'facebookId'  => 'required',
            'accessToken' => 'required',
        ];

        $messages = [
            'facebookId.required'  => TranslationCode::ERROR_FACEBOOK_ID_REQUIRED,
            'accessToken.required' => TranslationCode::ERROR_FACEBOOK_ACCESS_TOKEN_REQUIRED
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Validate request on google login
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateGoogleLoginRequest(Request $request)
    {
        $rules = [
            'googleId'    => 'required',
            'accessToken' => 'required',
        ];

        $messages = [
            'googleId.required'    => TranslationCode::ERROR_GOOGLE_ID_REQUIRED,
            'accessToken.required' => TranslationCode::ERROR_GOOGLE_ACCESS_TOKEN_REQUIRED
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Login user with social
     *
     * @param  SocialiteUser  $socialUser
     * @param  Language  $language
     * @param  string  $socialId
     *
     * @return User
     */
    public function loginUserWithSocial(SocialiteUser $socialUser, Language $language, string $socialId)
    {
        $builder = self::getUserBuilderForLogin();

        $user = $builder->where(function ($query) use ($socialUser, $socialId) {
            $query->where($socialId, $socialUser->getId())
                  ->orWhereEncrypted('email', $socialUser->getEmail());
        })->first();

        if (!$user) {
            $user = new User();

            $user->language_id = $language->id;
            $user->name        = $socialUser->getName();
            $user->email       = $socialUser->getEmail();

            if ($socialUser->getAvatar()) {
                $baseService = new BaseService();

                $path = 'uploads/users/';
                File::makeDirectory($path, 0777, true, true);

                $generatedPictureName = time() . '.jpg';

                $pictureData = $baseService->processImage($path, $socialUser->getAvatar(), $generatedPictureName, true,
                    true);

                if ($pictureData) {
                    $user->picture = $pictureData;
                }
            }
        }

        $user->status    = User::STATUS_CONFIRMED;
        $user->$socialId = $socialUser->getId();

        $user->save();

        return $user;
    }

    /**
     * Validate request on register
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateRegisterRequest(Request $request)
    {
        $rules = [
            'name'           => 'required|name',
            'email'          => 'required|email|unique_encrypted:users,email',
            'password'       => 'required|min:8|regex:/^.*(?=.{3,})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[\d\X])(?=.*[^a-zA-Z\d\s:]).*$/',
            'retypePassword' => 'required|same:password'
        ];

        $messages = [
            'name.required'           => TranslationCode::ERROR_REGISTER_NAME_REQUIRED,
            'name.name'               => TranslationCode::ERROR_REGISTER_NAME_NAME,
            'email.required'          => TranslationCode::ERROR_REGISTER_EMAIL_REQUIRED,
            'email.email'             => TranslationCode::ERROR_REGISTER_EMAIL_INVALID,
            'email.unique_encrypted'  => TranslationCode::ERROR_REGISTER_EMAIL_REGISTERED,
            'password.required'       => TranslationCode::ERROR_REGISTER_PASSWORD_REQUIRED,
            'password.min'            => TranslationCode::ERROR_REGISTER_PASSWORD_MIN8,
            'password.regex'          => TranslationCode::ERROR_REGISTER_PASSWORD_COMPLEXITY,
            'retypePassword.required' => TranslationCode::ERROR_REGISTER_RETYPE_PASSWORD_REQUIRED,
            'retypePassword.same'     => TranslationCode::ERROR_REGISTER_RETYPE_PASSWORD_SAME
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Validate request on update user
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateUpdateUserRequest(Request $request)
    {
        $rules = [
            'name'           => 'required|name',
            'email'          => 'required|email',
            'oldPassword'    => 'required_with:newPassword',
            'newPassword'    => 'nullable|min:8|regex:/^.*(?=.{3,})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[\d\X])(?=.*[^a-zA-Z\d\s:]).*$/',
            'retypePassword' => 'required_with:newPassword|same:newPassword',
            'language'       => 'required|exists:languages,code'
        ];

        $messages = [
            'name.required'                => TranslationCode::ERROR_UPDATE_NAME_REQUIRED,
            'name.name'                    => TranslationCode::ERROR_UPDATE_NAME_NAME,
            'email.required'               => TranslationCode::ERROR_UPDATE_EMAIL_REQUIRED,
            'email.email'                  => TranslationCode::ERROR_UPDATE_EMAIL_INVALID,
            'oldPassword.required_with'    => TranslationCode::ERROR_UPDATE_OLD_PASSWORD_REQUIRED,
            'newPassword.min'              => TranslationCode::ERROR_UPDATE_NEW_PASSWORD_MIN8,
            'newPassword.regex'            => TranslationCode::ERROR_UPDATE_NEW_PASSWORD_COMPLEXITY,
            'retypePassword.required_with' => TranslationCode::ERROR_UPDATE_RETYPE_PASSWORD_REQUIRED,
            'retypePassword.same'          => TranslationCode::ERROR_UPDATE_RETYPE_PASSWORD_SAME,
            'language.required'            => TranslationCode::ERROR_UPDATE_LANGUAGE_REQUIRED,
            'language.exists'              => TranslationCode::ERROR_UPDATE_LANGUAGE_EXISTS,
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Update logged user
     *
     * @param  User  $user
     * @param  Request  $request
     * @param  Language  $language
     */
    public function updateLoggedUser(User &$user, Request $request, Language $language)
    {
        $email        = $request->get('email');
        $confirmEmail = false;

        if ($user->email !== $email) {
            $user->email           = $email;
            $user->status          = User::STATUS_EMAIL_UNCONFIRMED;
            $user->activation_code = strtoupper(Str::random(6));

            $confirmEmail = true;
        }

        if ($request->has('newPassword')) {
            $user->password = Hash::make($request->get('newPassword'));
        }

        $user->name = $request->get('name');

        $user->language_id = $language->id;

        if ($confirmEmail) {
            $emailService = new EmailService();

            $emailService->sendEmailConfirmationCode($user, $language->code);
        }

        $user->save();
    }

    /**
     * Validate request on update user picture
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateUpdateUserPictureRequest(Request $request)
    {
        $rules = [
            'picture' => 'required|image',
        ];

        $messages = [
            'picture.required' => TranslationCode::ERROR_UPDATE_PICTURE_REQUIRED,
            'picture.image'    => TranslationCode::ERROR_UPDATE_PICTURE_IMAGE
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Change logged user picture
     *
     * @param $user
     * @param $picture
     */
    public function updateLoggedUserPicture(&$user, $picture)
    {
        /** @var User $user */
        $user = Auth::user();

        $pictureExtension     = $picture->getClientOriginalExtension();
        $generatedPictureName = str_replace(' ', '_', $user->name) . '_' . time() . '.' . $pictureExtension;

        $path = 'uploads/users/';
        File::makeDirectory($path, 0777, true, true);

        $baseService = new BaseService();

        $pictureData = $baseService->processImage($path, $picture, $generatedPictureName, true);

        if ($pictureData) {
            if ($user->picture) {
                foreach ($user->picture as $oldPicture) {

The expression $user->picture of type string is not traversable.

                    if ($oldPicture && file_exists($oldPicture)) {
                        unlink($oldPicture);
                    }
                }
            }

            $user->picture = $pictureData;
        }

        $user->save();
    }

    /**
     * Validate request on forgot password
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateForgotPasswordRequest(Request $request)
    {
        $rules = [
            'email' => 'required|email|exists_encrypted:users,email'
        ];

        $messages = [
            'email.required'         => TranslationCode::ERROR_FORGOT_EMAIL_REQUIRED,
            'email.email'            => TranslationCode::ERROR_FORGOT_EMAIL_INVALID,
            'email.exists_encrypted' => TranslationCode::ERROR_FORGOT_EMAIL_NOT_REGISTERED
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Send code on email for forgot password
     *
     * @param  User  $user
     * @param  Language  $language
     */
    public function sendForgotPasswordCode(User $user, Language $language)
    {
        $user->forgot_code = strtoupper(Str::random(6));
        $user->forgot_time = Carbon::now()->format('Y-m-d H:i:s');

        $emailService = new EmailService();

        $emailService->sendForgotPasswordCode($user, $language->code);

        $user->save();
    }

    /**
     * Validate request on forgot change password
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateChangePasswordRequest(Request $request)
    {
        $rules = [
            'email'          => 'required|email|exists_encrypted:users,email',
            'code'           => 'required',
            'password'       => 'required|min:8|regex:/^.*(?=.{3,})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[\d\X])(?=.*[^a-zA-Z\d\s:]).*$/',
            'retypePassword' => 'required|same:password'
        ];

        $messages = [
            'email.required'          => TranslationCode::ERROR_FORGOT_EMAIL_REQUIRED,
            'email.email'             => TranslationCode::ERROR_FORGOT_EMAIL_INVALID,
            'email.exists_encrypted'  => TranslationCode::ERROR_FORGOT_EMAIL_NOT_REGISTERED,
            'code.required'           => TranslationCode::ERROR_FORGOT_CODE_REQUIRED,
            'password.required'       => TranslationCode::ERROR_FORGOT_PASSWORD_REQUIRED,
            'password.min'            => TranslationCode::ERROR_FORGOT_PASSWORD_MIN8,
            'password.regex'          => TranslationCode::ERROR_FORGOT_PASSWORD_COMPLEXITY,
            'retypePassword.required' => TranslationCode::ERROR_FORGOT_RETYPE_PASSWORD_REQUIRED,
            'retypePassword.same'     => TranslationCode::ERROR_FORGOT_RETYPE_PASSWORD_SAME
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Update user password after reset
     *
     * @param  User  $user
     * @param $password
     */
    public function updatePassword(User $user, $password)
    {
        $user->forgot_code = null;
        $user->forgot_time = null;
        $user->password    = Hash::make($password);

        $user->save();
    }

    /**
     * Register user
     *
     * @param  Request  $request
     * @param  Language  $language
     */
    public function registerUser(Request $request, Language $language)
    {
        $user = new User();

        $user->name            = $request->get('name');
        $user->email           = $request->get('email');
        $user->password        = $request->get('password');
        $user->status          = User::STATUS_UNCONFIRMED;
        $user->language_id     = $language->id;
        $user->role_id         = Role::ID_USER;
        $user->activation_code = strtoupper(Str::random(6));

        $emailService = new EmailService();

        $emailService->sendActivationCode($user, $language->code);

        $user->save();
    }

    /**
     * Validate activate account
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateActivateAccountOrChangeEmailRequest(Request $request)
    {
        $rules = [
            'email' => 'required|email',
            'code'  => 'required'
        ];

        $messages = [
            'email.required' => TranslationCode::ERROR_ACTIVATE_EMAIL_REQUIRED,
            'email.email'    => TranslationCode::ERROR_ACTIVATE_EMAIL_INVALID,
            'code.required'  => TranslationCode::ERROR_ACTIVATE_CODE_REQUIRED
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Activate user account on register or on change email
     *
     * @param $email
     * @param $code
     *
     * @return bool
     */
    public function activateUserAccount($email, $code)
    {
        /** @var User|null $user */
        $user = User::whereEncrypted('email', $email)
                    ->where('activation_code', $code)
                    ->first();

        if (!$user) {

$user is of type App\Models\User, thus it always evaluated to true.

            return false;
        }

        $user->status          = User::STATUS_CONFIRMED;
        $user->activation_code = null;

        $user->save();

        return true;
    }

    /**
     * Validate request on resend
     *
     * @param  Request  $request
     *
     * @return ReturnedValidator
     */
    public function validateResendActivationCodeRequest(Request $request)
    {
        $rules = [
            'email' => 'required|email'
        ];

        $messages = [
            'email.required' => TranslationCode::ERROR_ACTIVATE_EMAIL_REQUIRED,
            'email.email'    => TranslationCode::ERROR_ACTIVATE_EMAIL_INVALID
        ];

        return Validator::make($request->all(), $rules, $messages);
    }

    /**
     * Resend registration mail
     *
     * @param  Request  $request
     *
     * @return array|bool
     */
    public function resendRegisterMail(Request $request)
    {
        /** @var User|null $user */
        $user = User::whereEncrypted('email', $request->get('email'))->first();

        if (!$user) {

$user is of type App\Models\User, thus it always evaluated to true.

            return ['email' => TranslationCode::ERROR_ACTIVATE_EMAIL_NOT_REGISTERED];
        }

        if ($user->status === User::STATUS_CONFIRMED) {
            return ['account' => TranslationCode::ERROR_ACTIVATE_ACCOUNT_ACTIVATED];
        }

        if ($user->updated_at->addMinute() > Carbon::now()) {
            return ['code' => TranslationCode::ERROR_ACTIVATE_CODE_SEND_COOLDOWN];
        }

        $emailService = new EmailService();

        $emailService->sendActivationCode($user, $user->language->code);

        $user->updated_at = Carbon::now()->format('Y-m-d H:i:s');
        $user->save();

        return false;
    }
}