File Manager

Editing File: /home/ubuntu/vedadeals-backend-base/app/Http/Controllers/Api/UserApiController.php

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;

use Illuminate\Http\Request;

use App\Helpers\Helper;

use DB, Exception, Setting, Hash, Storage;

use App\Models\{ User, Wallet, PasswordReset, UserWallet, Cart, UserWithdrawal };

use App\Services\{ EmailService };

use Illuminate\Validation\Rule;

use App\Jobs\SendEmailJob;

class UserApiController extends Controller
{
    protected $loginUser;

protected $skip, $take;

public function __construct(Request $request) {

info(url()->current());

info("Request Data".print_r($request->all(), true));
        
        $this->loginUser = User::find($request->id);

$this->skip = $request->skip ? : 0;

$this->take = $request->take ? : (Setting::get('admin_take_count') ? : TAKE_COUNT);

$this->timezone = $this->loginUser->timezone ?? "America/New_York";

$request->request->add(['time_zone' => $this->timezone]);

}

/**
     * @method register()
     *
     * @uses for user registration
     * 
     * @created Karthick
     *
     * @updated
     *
     * @param
     *
     * @return Json response with user details
     */
    public function register(Request $request) {

try {

$basic_rule = ['login_by' => 'required', Rule::in(MANUAL, FACEBOOK, GOOGLE)];

Helper::custom_validator($request->all(), $basic_rule, $custom_errors = []);

if(in_array($request->login_by, [FACEBOOK, GOOGLE])) {

$rules = [
                        'social_unique_id' => 'required',
                        'name' => 'nullable|max:255',
                        'email' => 'required|email|max:255',
                       // 'dob' => ['nullable', 'date']
                    ];

} else {

$rules = [
                        'name' => 'required|max:255',
                        // 'username' => 'required|unique:users,username|regex:/^[a-zA-Z0-9-]+$/u',
                        'email' => 'required|email|max:255|unique:users,email',
                        'password' => 'required|min:6',
                       // 'dob' => ['nullable', 'date']
                    ];

}

$custom_errors = [ 'regex' => api_error(121) ];

$validated = Helper::custom_validator($request->all(), $rules, $custom_errors);

DB::beginTransaction();

$user = User::firstWhere('email' , $request->email);

$send_email = NO;

// Creating the user

if(!$user) {

$user = new User;

$send_email = YES;

} elseif (in_array($user->status, [USER_PENDING , USER_DECLINED])) {
                
                throw new Exception(api_error(1000), 1000);
            }

$user->name = $request->name ?? "";

$user->email = $request->email ?? "";

$user->mobile = $request->mobile ?? "";

$user->username = $request->username ?? "";

$user->timezone = $request->timezone ?? "";

$user->social_unique_id = $request->social_unique_id ? : "";

$user->device_token = $request->device_token ? : $user->device_token;

$user->device_type = $request->device_type ? : $user->device_type;

$user->login_by = $request->login_by ? : $user->login_by;

//           $user->dob = $request->dob ? : $user->dob;

$user->state = $request->state ? : $user->state;

$user->country = $request->country ? : $user->country;

$user->country_code = $request->country_code ? : $user->country_code;

$user->password = '';

if($request->has('password') && $request->login_by == MANUAL) {

$user->password = $request->password ? : "";

}

if($user->save()) {

if($send_email) {

EmailService::send_user_welcome_email($user);

}

if(in_array($user->status , [USER_DECLINED , USER_PENDING])) {
                
                    $response = ['success' => false , 'error' => api_error(1000) , 'error_code' => 1000];

DB::commit();

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

if($user->is_email_verified == USER_EMAIL_VERIFIED) {
                    
                    $data = User::find($user->id);

if($user->wasRecentlyCreated) {

$success_code = 101;

} elseif($user->login_by != MANUAL) {

$success_code = 102;
                    }

$response = ['success' => true, 'message' => api_success($success_code), 'data' => $data];

} else {

$data = User::find($user->id);

$response = ['success' => true, 'message' => api_error(1001), 'code' => 1001, 'data' => $data];

DB::commit();

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

}

} else {

throw new Exception(api_error(103), 103);

}

DB::commit();

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

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());

}
   
    }

/**
     * @method login()
     *
     * @uses for user login
     * 
     * @created Karthick
     *
     * @updated 
     *
     * @param object $request - email, password, device_type, login_by
     *
     * @return Json response with user details
     */
    public function login(Request $request) {

try {
            
            DB::beginTransaction();

$rules = [
                        'email' => 'required|exists:users,email',
                        'password' => 'required',
                    
                    ];

$custom_errors = ['email.exists' => api_error(1002)];

$validated = Helper::custom_validator($request->all(), $rules, $custom_errors);

$user = User::where('email', $request->email)->where('status', USER_APPROVED)->first();

if(!$user) {

throw new Exception(api_error(100), 100);

}
            
            if(Hash::check($request->password, $user->password)) {

$user->state = $request->state ? : $user->state;
            
                $user->country = $request->country ? : $user->country;

$user->country_code = $request->country_code ? : $user->country_code;

if($user->is_email_verified != USER_EMAIL_VERIFIED) {

$response = ['success' => true, 'message' => api_error(1001), 'code' => 1001, 'data' => $user];

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

}

if ($user->is_two_step_auth_enabled) {

$user->verification_code = Helper::generate_email_code();

$user->verification_code_expiry = Helper::generate_email_expiry();

$user->save();
                
                    DB::commit();

$user = User::find($user->id);

EmailService::send_two_step_verification_code_email($user);
                    
                    return $this->sendResponse(api_success(114), $success_code = 114, $data = $user);
                }
                
                $user->token = Helper::generate_token();

$user->token_expiry = Helper::generate_token_expiry();
                
                $user->device_token = $request->device_token ? : $user->device_token;

$user->device_type = $request->device_type ? : $user->device_type;

$user->login_by = $request->login_by ? : $user->login_by;

$user->timezone = $request->timezone ? : $user->timezone;

$user->is_logged_in = YES;

$user->save();
                
                DB::commit();

$user = User::find($user->id);

return $this->sendResponse(api_success(102), 102, $user);

} else {

throw new Exception(api_error(1007), 1007);

}

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());
        }
    }

/** 
     * @method profile()
     *
     * @uses to get the user details
     *
     * @created Karthick 
     *
     * @updated 
     *
     * @param object $request - if
     *
     * @return json response with user details
     */

public function profile(Request $request) {

try {

$user = User::withCount(['bellNotifications', 'unReadBellNotifications'])->find($request->id);

if(!$user) {

throw new Exception(api_error(1002) , 1002);
            }

$user->created_formatted = common_date($user->created_at, $this->timezone, 'd M Y');

$user->updated_formatted = common_date($user->updated_at, $this->timezone, 'd M Y');

$user->cart_count = Cart::has('product')->where('user_id', $request->id)->count();

Helper::cache_update_for_products($user->id, '');

return $this->sendResponse($message = "", $success_code = "", $user);

} catch(Exception $e) {

return $this->sendError($e->getMessage(), $e->getLine());

}
    
    }

/**
     * @method update_profile()
     *
     * @uses to update the user details
     *
     * @created Karthick 
     *
     * @updated
     *
     * @param objecct $request : user details
     *
     * @return json response with updated user details
     */
    public function update_profile(Request $request) {

try {

$rules = [
                        'name' => 'required|max:255',
                        // 'username' => 'required|unique:users,username,'.$request->id.'|regex:/^[a-zA-Z0-9-]+$/u',
                        'email' => 'email|max:255|unique:users,email,'.$request->id,
                        'mobile' => 'nullable|digits_between:6,13',
                        'picture' => 'nullable|mimes:jpg,png,jpeg',
                        'cover' => 'nullable|mimes:jpg,png,jpeg',
                        'gender' => 'nullable|in:male,female,others,rather-not-select',
                        'about' => 'nullable|max:250',
                        'wallet_address' => 'nullable',
                       // 'dob' => ['nullable', 'date']
                    ];

$custom_errors = [ 'regex' => api_error(121) ];

$validated = Helper::custom_validator($request->all(), $rules, $custom_errors);
            
            $user = User::find($request->id);

DB::beginTransaction();

$user->update($validated);
            
            if($request->hasFile('picture')) {

Helper::storage_delete_file($user->picture, PROFILE_PATH_USER);

$user->picture = Helper::storage_upload_file($request->file('picture'), PROFILE_PATH_USER);
            
            }

if($request->hasFile('cover')) {

Helper::storage_delete_file($user->cover, PROFILE_PATH_USER);

$user->cover = Helper::storage_upload_file($request->file('cover'), PROFILE_PATH_USER);
            
            }

if($user->save()) {

$user->cart_count = Cart::has('product')->where('user_id', $request->id)->count();

DB::commit();

return $this->sendResponse(api_success(103),  103, $user);

} else {

throw new Exception(api_error(1005), 1005);
            }

} catch (Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());
        }
    }

/**
     * @method delete_account()
     * 
     * @uses to delete an user account
     *
     * @created Karthick
     *
     * @updated 
     *
     * @param object $request - id, password
     *
     * @return json results
     */

public function delete_account(Request $request) {

try {

DB::beginTransaction();

$request->request->add(['login_by' => $this->loginUser ? $this->loginUser->login_by : "manual"]);

$rules = ['password' => 'required_if:login_by,manual'];

Helper::custom_validator($request->all(), $rules, $custom_errors = []);

$user = User::find($request->id);

if($user->login_by == 'manual') {

if(!Hash::check($request->password, $user->password)) {
         
                    throw new Exception(api_error(1007), 1007); 
                }
            
            }

if($user->delete()) {

DB::commit();

return $this->sendResponse(api_success(109), 109, []);

} else {

throw new Exception(api_error(1008), 1008);
            }

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());
        }

}

/**
     * @method change_password()
     *
     * @uses to change the use password
     *
     * @created Karthick
     *
     * @updated 
     *
     * @param - 
     *
     * @return JSON Response
     */
    public function change_password(Request $request) {

try {

$rules = [
                'old_password' => 'required|min:6',
                'password' => 'required|confirmed|min:6',
            ];

Helper::custom_validator($request->all(), $rules, $custom_errors =[]);

$user = User::find($request->id);

if($user->login_by != "manual") {

throw new Exception(api_error(1010), 1010);
                
            }

if(!Hash::check($request->old_password, $user->password)) {

throw new Exception(api_error(1007), 1007);
                
            }

DB::beginTransaction();

$result = $user->update(['password' => Hash::make($request->password)]);
            
            if(!$result) {

throw new Exception(api_error(1011), 1011); 
            
            }

DB::commit();

EmailService::send_change_password_email($user);

return response()->json(['success' => true, 'message' => api_success(110), 'code' => 110]);

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());

}

/**
     * @method forgot_password()
     *
     * @uses to send forgot password email
     *
     * @created Karthick
     *
     * @updated 
     *
     * @param - 
     *
     * @return JSON Response
     */
    public function forgot_password(Request $request) {

try {

$rules = ['email' => 'required|exists:users,email'];

Helper::custom_validator($request->all(), $rules, $custom_errors =[]);

$user = User::firstWhere('email', $request->email);

DB::beginTransaction();

$token = app('auth.password.broker')->createToken($user);
    
            PasswordReset::where('email', $user->email)->delete();
    
            PasswordReset::insert([
                'email' => $user->email,
                'token' => $token,
                'created_at' => now()
            ]);

DB::commit();

EmailService::send_forgot_password_email($user, $token);

return response()->json(['success' => true, 'message' => api_success(111), 'code' => 111]);

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());

}

/**
     * @method logout()
     *
     * @uses Logout the user
     *
     * @created Karthick
     *
     * @updated 
     *
     * @param 
     * 
     * @return
     */
    public function logout(Request $request) {

$this->loginUser->update(['is_logged_in' => NO]);

return response()->json(['success' => true, 'message' => api_success(106), 'code' => 106]);

}

/**
     * @method verify_email()
     *
     * @uses 
     *
     * @created Arun
     *
     * @updated 
     *
     * @param request id
     *
     * @return JSON Response
     */
    public function verify_email(Request $request) {

try {

DB::beginTransaction();
            
            $rules = [
                'email' => 'required|exists:users,email',
                'verification_code' => 'required|min:6|max:6'
            ];

Helper::custom_validator($request->all(), $rules, $custom_errors = []);

$user = User::where('email', $request->email)->first();

if (!$user) {
                
                throw new Exception(api_error(100), 100);
            }

if($user->verification_code != $request->verification_code) {

throw new Exception(api_error(101), 101);

}

$user->is_email_verified = USER_EMAIL_VERIFIED;

$user->save();

DB::commit();

$data = User::find($user->id);

return $this->sendResponse($message = api_success(112), $code = 112, $data);

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());
        
        }
    
    }

/**
     * @method resend_email_verification_code()
     *
     * @uses 
     *
     * @created vithya R
     *
     * @updated Vidhya R, Karthick
     *
     * @param request email
     *
     * @return JSON Response
     */
    public function resend_email_verification_code(Request $request) {

try {

$rules = [ 'email' => 'required|exists:users,email' ];

Helper::custom_validator($request->all(), $rules);

DB::beginTransaction();

$user = User::firstWhere(['email' => $request->email]);

if(!$user) {

throw new Exception(api_error(100), 100);
            }

$user->verification_code = Helper::generate_email_code();

$user->verification_code_expiry = Helper::generate_email_expiry();

$user->save();

EmailService::user_register_job($user);

DB::commit();

return $this->sendResponse($message = api_success(113), $code = 113, $data = []);

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());
        
        }
    
    }

/**
     * @method two_step_auth_login()
     *
     * @uses To login via two step verification
     *
     * @created Arun
     *
     * @updated
     *
     * @param request email,code
     *
     * @return JSON Response
     */
    public function two_step_auth_login(Request $request) {

try {
            
            DB::beginTransaction();

$user = User::where('email', $request->email)->first();

if(!$user) {

throw new Exception(api_error(1002), 1002);

}

if($user->is_two_step_auth_enabled == NO) {

throw new Exception(api_error(102), 102);

}

$rules = [
                'email' => 'required|exists:users,email',
                'code' => 'required|min:6|max:6|exists:users,verification_code,email,'.$request->email,
              //  'dob' => ['nullable', 'date']
            ];

Helper::custom_validator($request->all(), $rules);

if($request->code == $user->verification_code){

$user->token = Helper::generate_token();

$user->token_expiry = Helper::generate_token_expiry();
                
                $user->verification_code = '';

$user->verification_code_expiry = '';

$user->device_token = $request->device_token ? : $user->device_token;

$user->device_type = $request->device_type ? : $user->device_type;

$user->login_by = $request->login_by ? : $user->login_by;

$user->timezone = $request->timezone ? : $user->timezone;

$user->dob = $request->dob ? : $user->dob;

$user->state = $request->state ? : $user->state;
            
                $user->country = $request->country ? : $user->country;

$user->country_code = $request->country_code ? : $user->country_code;

$user->save();
            
                DB::commit();

$data = User::find($user->id);
                
                DB::commit();

return $this->sendResponse(api_success(102), 102, $data);

} else {

throw new Exception(api_error(101), 101);

}

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());

}
    
    }

/**
     * @method two_step_auth_update()
     *
     * @uses To enable/disable the two step verification
     *
     * @created Arun
     *
     * @updated
     *
     * @param request id,email,password
     *
     * @return JSON Response
     */
    public function two_step_auth_update(Request $request) {

try {
            
            DB::beginTransaction();

$rules = [
                'password' => 'required',
            ];

Helper::custom_validator($request->all(), $rules);

$user = User::where('id', $request->id)->first();

// Check the user details

if(!$user) {

throw new Exception(api_error(1002), 1002);

}
            
            if(Hash::check($request->password, $user->password)) {

$user->is_two_step_auth_enabled = $user->is_two_step_auth_enabled ? NO : YES;

$user->save();

$data = User::find($user->id);

$data['cart_count'] = Cart::has('product')->where('user_id', $request->id)->count();

$code = $user->is_two_step_auth_enabled == YES ? 115 : 116; 
                
                DB::commit();

return $this->sendResponse(api_success($code), $code, $data);

} else {

throw new Exception(api_error(1007), 1007);

}

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());

}
    
    }

/**
     * @method resend_two_step_auth_code()
     *
     * @uses To resend the two step verification code
     *
     * @created Arun
     *
     * @updated
     *
     * @param request id
     *
     * @return JSON Response
     */
    public function resend_two_step_auth_code(Request $request) {

try {
            
            DB::beginTransaction();

$rules = [ 'email' => 'required' ];

Helper::custom_validator($request->all(), $rules);

$user = User::where('email', $request->email)->first();

// Check the user details

if(!$user) {

throw new Exception(api_error(1002), 1002);

}

if($user->is_two_step_auth_enabled == NO) {

throw new Exception(api_error(102), 102);

}

$user->verification_code = Helper::generate_email_code();

$user->verification_code_expiry = Helper::generate_email_expiry();

$user->save();
        
            DB::commit();

$user = User::find($user->id);

EmailService::send_two_step_verification_code_email($user);
            
            $response = ['success' => true, 'message' => api_success(114), 'code' => 114];

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

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());

}
    
    }

/**
     * @method username_validation()
     *
     * @uses to validate a username is already exists or not while user registration.
     *
     * @created Karthick
     *
     * @updated 
     *
     * @param username
     * 
     * @return success / failure message.
     */
    public function username_validation(Request $request) {

try {
            
            $rules = [ 'username' => 'required|regex:/^[a-zA-Z0-9-]+$/u' ];

$custom_errors = [ 'regex' => api_error(121) ];

Helper::custom_validator($request->all(), $rules, $custom_errors);

$user = User::where(['username' => $request->username])->exists();
           
            if($user) {

throw new Exception(api_error(120), 120);
            }
            
            return $this->sendResponse(api_success(130), 130, []);

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());
        }
    }

/**
     * @method reset_password()
     *
     * @uses to reset the password
     *
     * @created Karthick
     *
     * @updated
     *
     * @param object $request - reset_token
     *
     * @return success / failure message.
     */
    
    public function reset_password(Request $request) {

try {

$rules = [ 'password' => 'required|confirmed|min:6', 'reset_token' => 'required|string|exists:password_resets,token' ];

Helper::custom_validator($request->all(), $rules, $custom_errors = []);

DB::beginTransaction();

$password_reset = PasswordReset::firstWhere(['token' => $request->reset_token]);
            
            $user = User::firstWhere(['email' => $password_reset->email]);

$user->password = Hash::make($request->password);

$user->save();

$result = PasswordReset::where('email', $user->email)->delete();

DB::commit();

EmailService::send_reset_password_email($user);

return $this->sendResponse(api_success(131), 131, []);

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());
        }
   }

public function email_test(Request $request) {

try {

$user = User::find($request->id);
            
            $withdrawal_request = UserWithdrawal::find($request->user_withdrawal_id);

// EmailService::send_user_welcome_email($user);
            // EmailService::send_admin_welcome_email($user);
            // EmailService::send_reset_password_email($user);
            // EmailService::send_change_password_email($user);
            // EmailService::send_forgot_password_email($user, "1234");
            // EmailService::send_forgot_password_success_email($user);
            // EmailService::send_two_step_verification_code_email($user);
            // EmailService::send_withdrawal_request_paid_email($user->id, 10);
            // EmailService::send_withdrawal_request_rejected_email($withdrawal_request);
            // EmailService::send_withdrawal_request_cancelled_email($withdrawal_request);
            // EmailService::user_register_job($user);
            EmailService::order_status_email($request->order_unique_id);
            
            return $this->sendResponse(api_success(111), 111, []);

} catch(Exception $e) {

DB::rollback();

return $this->sendError($e->getMessage(), $e->getCode());
        }
    }

}

Back to Directory File Manager