RootZanli & NinjaCr3

: / home / o5t6x7pgljbm / www / app / Http / Controllers / Api /
Filename : TaskController.php
back
<?php

namespace App\Http\Controllers\Api;

use Illuminate\Http\Request;

use App\Http\Controllers\Controller;
use App\Models\Task;
use App\Models\Goal;
use App\Models\TaskAssigned;
use App\Models\Store;
use App\Models\StoreProduct;
use App\Models\ProductClaimed;
use App\Models\Product;
use App\Models\TaskAssignedApprovalFile;
use App\Models\User;
use App\Models\Group;

use Helpers;
use DB;
use Carbon\Carbon;
use Config;
use Illuminate\Support\Facades\Log;

class TaskController extends Controller
{

    public function create_task(Request $request)
    {
        $validated = $request->validate([
            'task_title' => 'required',
            'description' => 'required',
            'goal_id' => 'required',
            'task_type' => 'required',
            'assign_to' => 'required',
        ]);

        $user = $request->user();

        $request['task_sp'] = Goal::find($request->goal_id)->scholarship_points;
        $request['due_by'] = (isset($request->due_by) && !empty($request->due_by)) ? date("Y-m-d", strtotime($request->due_by)) : NULL;
        $request['product_id'] = ($request->task_type == 'ADDITIONAL_REWARD') ? $request->product_id : NULL;
        $request['group_id'] = $user->active_group_id;
        $request['created_by'] = $user->user_id;

        $task = Task::create($request->all());

        /* Notification Code - Start */
        $androidDeviceToken = $iosDeviceToken = [];
        $title = 'Task Assigned';
        $msg = $request->task_title.' task has been assigned.';
        $type = 'tasks';
        /* Notification Code - End */

        foreach($request->assign_to as $user_id){
            TaskAssigned::insert([
                'user_id' => $user_id,
                'task_id' => $task->task_id,
                'created_at' => date("Y-m-d H:i:s")
            ]);

            /* Notification Code - Start */
            $assignedUser = User::find($user_id);

            if($assignedUser->device_type == 'android'){
               $androidDeviceToken[] = $assignedUser->device_token;
            } else if($assignedUser->device_type == 'ios'){
               $iosDeviceToken[] = $assignedUser->device_token;
            }
            /* Notification Code - End */
        }
        /* Notification Code - Start */
        if(!empty($androidDeviceToken)){
           Helpers::sendPushAndroid($androidDeviceToken, $title, $msg, $type, $task->task_id);
        }
        if(!empty($iosDeviceToken)){
           Helpers::sendPushIOS($iosDeviceToken, $title, $msg, $type, $task->task_id);
        }
        Helpers::storeNotifications($user->user_id, array($request->assign_to), $title, $msg, 'tasks', $task->task_id);
        /* Notification Code - End */

        if($task && $task->task_sp > 0){
            $fix_tuit_points = 10;
            $tuitWalletController = new TUITWalletController();
                $wallet = $tuitWalletController->debitTUIT($user, $fix_tuit_points,
                    [
                        'transaction_title' => "task created",
                        'ref_table' => "tasks",
                        'ref_table_id' => $task->task_id,
                        'description' => "$fix_tuit_points tuit rewarded by create task of task id: $task->task_id"
                    ]);
        }

        return Helpers::responseMessage(200, 'Task created successfully.');
    }

    /**
     * json:
     * {
     *      "task_id": 12, -- non updatable
     *      "goal_id": 45, -- non updatable
     *      "task_title": "title 1",
     *      "description" "description",
     *      "task_type": "" -- non updatable
     *      "add_assigned_to": [56,43,56] -- list of user id whom the task needs to be assigned
     *      "remove_assigned_to": [54,65] -- list of user id for whom the task needs to be removed
     *      "due_by":"2023-11-17", - can due date in past?
     *      "product_id":"" -- only if the task type is "ADDITIONAL_REWARD",
     *      "updated_by":"" -- this field is not present,
     *      "task_sp": 45
     * }
     */
    public function edit_task(Request $request) {
        $error_list = array();
        $validated = $request->validate([
            'task_id' => 'required',
            'task_sp' => 'numeric',
            'due_by' => 'date_format:Y-m-d'
        ]);

        $user = $request->user();
        $task = Task::select("*")->where("task_id", $request->task_id)->first();

        if(isset($request->task_title)){
            $task->task_title=$request->task_title;
        }
        if(isset($request->description)){
            $task->description=$request->description;
        }
        if(isset($request->due_by)){
            $task->due_by=date("Y-m-d", strtotime($request->due_by));
        }
        if(isset($request->product_id) && $request->task_type =='ADDITIONAL_REWARD'){
            $product = Product::select("*")->where("product_id", $request->product_id)->first();
            //only if product is present with provide id, product id will be updated
            if(isset($product))
                $task->product_id=$request->product_id;
            else
                $error_list[] = "product id is not valid";
        }
        if(isset($request->task_type)){
            $task->task_type=$request->task_type;
        }
        if(isset($request->task_sp)){
            $task->task_sp=$request->task_sp;
        }
        if(isset($request->task_status)){
            $task->task_status=$request->task_status;
        }
        $saveResponse = $task->save();
        if($saveResponse){
            //update assignee
            if(isset($request->add_assign_to)){
                foreach($request->add_assign_to as $user_id){
                    if(!TaskAssigned::isTaskAssignmentPresent($user_id, $task->task_id))
                        TaskAssigned::insert([
                            'user_id' => $user_id,
                            'task_id' => $task->task_id,
                            'created_at' => date("Y-m-d H:i:s")
                        ]);
                }
            }

            if(isset($request->remove_assign_to)){
                foreach($request->remove_assign_to as $user_id){
                    if(TaskAssigned::isTaskAssignmentPresent($user_id, $task->task_id))
                        TaskAssigned::where("user_id", $user_id)
                                ->where("task_id", $task->task_id)
                                ->delete();
                }
            }
        }
        return $saveResponse ? Helpers::responseMessage(200, 'Task updated successfully.')
                    : Helpers::responseMessage(500, 'Task updatation failed.');
    }

    public function manage_tasks(Request $request)
    {

        $user = $request->user();

        $isGroupOwner = CommonController::is_group_owner($request);

        $fromDate = date("Y-m-d");
        $toDate = date("Y-m-d", strtotime("+3 days"));

        $data['task_due_soon_cnt'] = Task::where('group_id', $user->active_group_id)->whereBetween('due_by', [$fromDate, $toDate])->count();

        $data['task_due_soon'] = NULL;
        $query = Task::select('tasks.task_id', 'goals.goal_name', 'tasks.task_title', "tasks.description", 'tasks.task_sp', 'tasks.due_by',
                        'tasks.due_by as due_by_date', 'task_type', 'products.product_name', 'products.product_sp', 'products.product_id',
                        'goals.goal_color')
                        ->leftJoin('goals', 'goals.goal_id', 'tasks.goal_id')
                        /*->leftJoin('products', 'products.product_id', 'tasks.product_id')*/
                        ->leftJoin('products', function($join)
                         {
                           $join->on('products.product_id', '=', 'tasks.product_id');
                           $join->where('products.status', '=', 'ACTIVE');
                         })
                        ->where('tasks.group_id', $user->active_group_id)
                        ->whereNotNull('due_by')
                        ->whereBetween('due_by', [$fromDate, $toDate]);
                    if(!$isGroupOwner){
                        $query->whereIn('tasks.task_id',function($query) use ($user){
                            $query->select('task_id')->from('task_assigned')->where('user_id', $user->user_id);
                        });
                    }
        $taskDueSoon = $query->orderBy('tasks.created_at', 'desc')->first();

        if(!empty($taskDueSoon)){

            $data['task_due_soon'] = $taskDueSoon;
            if($isGroupOwner){
                $taskDueSoon->due_by = $taskDueSoon->due_by ? Helpers::dateDiffForHumans($taskDueSoon->due_by) : null;
                $data['task_due_soon']['assign_to'] = TaskAssigned::select('users.user_id','users.full_name', DB::raw('CONCAT("'.Config::get('constants.app.api-profile-pic-thumb-url').'",profile_pic) as profile_pic'))
                                ->leftJoin('users', 'users.user_id', 'task_assigned.user_id')
                                ->where('task_id', $taskDueSoon->task_id)
                                ->limit(4)
                                ->get();
            } else {
                $taskDueSoon->due_by = $taskDueSoon->due_by ? Helpers::dateDiffForHumans($taskDueSoon->due_by) : null;
                $data['task_due_soon']['task_assigned'] = TaskAssigned::select('task_assigned_id','status')
                                ->where('task_id', $taskDueSoon->task_id)
                                ->where('user_id', $user->user_id)
                                ->first();
            }


        }

        $goals = Goal::all();
        foreach($goals as $goal){
            $categoryTasks['goal_id'] = $goal->goal_id;
            $categoryTasks['goal_name'] = $goal->goal_name;
            $categoryTasks['goal_color'] = $goal->goal_color;

            $query = Task::select('tasks.task_id', 'goals.goal_name', 'tasks.task_title', "tasks.description", 'tasks.task_sp', 'tasks.due_by', 'tasks.due_by as due_by_date', 'task_type', 'products.product_name', 'products.product_sp', 'products.product_id')
                        ->leftJoin('goals', 'goals.goal_id', 'tasks.goal_id')
                        /*->leftJoin('products', 'products.product_id', 'tasks.product_id')*/
                        ->leftJoin('products', function($join)
                         {
                           $join->on('products.product_id', '=', 'tasks.product_id');
                           $join->where('products.status', '=', 'ACTIVE');
                         })
                        ->where('tasks.goal_id', $goal->goal_id)
                        ->where('tasks.group_id', $user->active_group_id);
                    if(!$isGroupOwner){
                        $query->whereIn('tasks.task_id',function($query) use ($user){
                            $query->select('task_id')->from('task_assigned')->where('user_id', $user->user_id);
                        });
                    }
                    $tasks =  $query->orderBy('tasks.created_at', 'desc')->limit(3)->get();

            $categoryTasks['tasks'] = [];
            foreach($tasks as $task){
                $categoryTask = $task;
                if($isGroupOwner){
                    $task->due_by = $task->due_by ?  Helpers::dateDiffForHumans($task->due_by) : null;
                    $categoryTask['assign_to'] = TaskAssigned::select('users.user_id','users.full_name', DB::raw('CONCAT("'.Config::get('constants.app.api-profile-pic-thumb-url').'",profile_pic) as profile_pic'))
                                    ->leftJoin('users', 'users.user_id', 'task_assigned.user_id')
                                    ->where('task_id', $task->task_id)
                                    ->limit(4)
                                    ->get();
                } else {
                    $task->due_by =  $task->due_by ?  Helpers::dateDiffForHumans($task->due_by) : null;
                    $categoryTask['task_assigned'] = TaskAssigned::select('task_assigned_id','status')
                                ->where('task_id', $task->task_id)
                                ->where('user_id', $user->user_id)
                                ->first();
                }

                $categoryTasks['tasks'][] = $categoryTask;
            }
            $data['goals'][] = $categoryTasks;
        }

        $resData['data'] = $data;

        return Helpers::successResponse($resData, 200, 'Tasks fetched successfully.');

    }

    public function filter_tasks(Request $request)
    {
        $validated = $request->validate([
            'status' => 'required',
        ]);

        $user = $request->user();

        $isGroupOwner = CommonController::is_group_owner($request);

        $fromDate = date("Y-m-d");
        $toDate = date("Y-m-d", strtotime("+3 days"));

        $taskData['task_due_soon_cnt'] = Task::where('group_id', $user->active_group_id)->whereBetween('due_by', [$fromDate, $toDate])->count();

        $query = TaskAssigned::select('tasks.task_id', 'goals.goal_name', 'tasks.task_title', "tasks.description", 'tasks.task_sp', 'tasks.due_by', 'tasks.due_by as due_by_date', 'task_type', 'products.product_name', 'products.product_sp', 'products.product_id')
                ->leftJoin('tasks', 'tasks.task_id', 'task_assigned.task_id')
                ->leftJoin('goals', 'goals.goal_id', 'tasks.goal_id')
               /* ->leftJoin('products', 'products.product_id', 'tasks.product_id')*/
                ->leftJoin('products', function($join)
                 {
                   $join->on('products.product_id', '=', 'tasks.product_id');
                   $join->where('products.status', '=', 'ACTIVE');
                 })
                ->where('task_assigned.status', $request->status)
                ->where('tasks.group_id', $user->active_group_id);
                if(isset($request->goal_id)){
                    $query->where('tasks.goal_id', $request->goal_id);
                }
                if(!$isGroupOwner){
                    $query->where('task_assigned.user_id', $user->user_id);
                }
                $query->orderBy('tasks.created_at', 'desc');
                $query->groupBy('tasks.task_id');

        $tasks = $query->paginate(10);
        $items = $tasks->getCollection();
        foreach ($items as $key => $item) {
            if($isGroupOwner){
                $item->due_by = $item->due_by ? Helpers::dateDiffForHumans($item->due_by) : null;
                $items[$key]['assign_to'] = TaskAssigned::select('users.user_id','users.full_name', DB::raw('CONCAT("'.Config::get('constants.app.api-profile-pic-thumb-url').'",profile_pic) as profile_pic'))
                                ->leftJoin('users', 'users.user_id', 'task_assigned.user_id')
                                ->where('task_id', $item->task_id)
                                ->where('task_assigned.status', $request->status)
                                ->limit(4)
                                ->get();
            } else {
                $item->due_by = $item->due_by ? Helpers::dateDiffForHumans($item->due_by) : null;
                $items[$key]['task_assigned'] = TaskAssigned::select('task_assigned_id','status')
                            ->where('task_id', $item->task_id)
                            ->where('user_id', $user->user_id)
                            ->first();
            }
        }
        $taskData['tasks'] = $tasks->setCollection($items);

       /* foreach($tasks as $task){
            $task->due_by = Helpers::dateDiffForHumans($task->due_by);
            $categoryTask = $task;
            $categoryTask['assign_to'] = TaskAssigned::select(DB::raw('CONCAT("'.Config::get('constants.app.api-profile-pic-thumb-url').'",profile_pic) as profile_pic'))
                                ->leftJoin('users', 'users.user_id', 'task_assigned.user_id')
                                ->where('task_id', $task->task_id)
                                ->where('status', $request->status)
                                ->limit(4)
                                ->get();

            $data['tasks'][] = $categoryTask;
        }*/

        $resData['data'] = $taskData;

        return Helpers::successResponse($resData, 200, 'Tasks fetched successfully.');
    }

    public function change_task_status(Request $request)
    {
        $validated = $request->validate([
            'task_assigned_id' => 'required',
            'status' => 'required',
        ]);

        $user = $request->user();

        $taskAssigned = TaskAssigned::find($request->task_assigned_id);
        $taskAssigned->status = $request->status;
        $taskAssigned->save();

        $task = $taskAssigned->task;

        /*if($request->status == 'APPROVED'){

            $store_id = Store::where('group_id', $user->active_group_id)->first()->store_id;

            if($task->product_id > 0){
                $store_product_id = StoreProduct::where('product_id', $task->product_id)->where('store_id', $store_id)->first()->store_product_id;

                $productClaimed = new ProductClaimed();
                $productClaimed->store_product_id = $store_product_id;
                $productClaimed->status = 'APPROVED';
                $productClaimed->user_id = $taskAssigned->user_id;
                $productClaimed->created_at = date("Y-m-d H:i:s");
                $productClaimed->save();
            }

            //$task = $taskAssigned->task;
            $task_assigned_to_user = $taskAssigned->assigned_to_user;
            if($task && $task->task_sp > 0){
                $spWalletController = new SPWalletController();
                $wallet = $spWalletController->debitSP( $task_assigned_to_user, $task->task_sp,
                    [ 'transaction_title' => "task claimed",
                    'ref_table' => "task_assigned",
                    'ref_table_id' => null,
                    'description' => "$task->task_sp sp rewarded by claim of task id: $task->task_id"]);
            }
        }*/

        /* Notification Code - Start */
        $androidDeviceToken = $iosDeviceToken = [];


        $title = 'Task Completed';
        $msg = $task->task_title.' task has been completed.';
        $type = 'tasks';
        $task = Task::find($taskAssigned->task_id);
        $taskOwner = User::find($task->created_by);
        if($taskOwner->device_type == 'android'){
           $androidDeviceToken[] = $taskOwner->device_token;
           Helpers::sendPushAndroid(array($taskOwner->device_token), $title, $msg, $type, $task->task_id);
        } else if($taskOwner->device_type == 'ios'){
           Helpers::sendPushIOS(array($taskOwner->device_token), $title, $msg, $type, $task->task_id);
        }
        Helpers::storeNotifications($user->user_id, array($taskAssigned->user_id), $title, $msg, 'tasks', $task->task_id);
        /* Notification Code - End */

        return Helpers::responseMessage(200, 'Task status updated successfully.');

    }

    public function mark_tasks_approved(Request $request)
    {
        $validated = $request->validate([
            'task_assigned_ids' => 'required',
        ]);

        $user = $request->user();

        if(is_array($request->task_assigned_ids)){
            foreach($request->task_assigned_ids as $task_assigned_id => $status){

                if($status == 'APPROVED' || $status == 'REJECTED'){
                    $taskAssigned = TaskAssigned::find($task_assigned_id);

                    if(!empty($taskAssigned)){
                        $taskAssigned->status = ($status == 'APPROVED' ? 'APPROVED' : 'PENDING');
                        $taskAssigned->save();

                        $task = $taskAssigned->task;

                        if($status == 'APPROVED'){
                            $store_id = Store::where('group_id', $user->active_group_id)->first()->store_id;

                            if($task->product_id > 0){
                                $store_product_id = StoreProduct::where('product_id', $task->product_id)->where('store_id', $store_id)->first()->store_product_id;

                                $productClaimed = new ProductClaimed();
                                $productClaimed->store_product_id = $store_product_id;
                                $productClaimed->status = 'APPROVED';
                                $productClaimed->user_id = $taskAssigned->user_id;
                                $productClaimed->created_at = date("Y-m-d H:i:s");
                                $productClaimed->save();
                            }

                            //$task = $taskAssigned->task;
                            $task_assigned_to_user = $taskAssigned->assigned_to_user;
                            if($task && $task->task_sp > 0){
                                $spWalletController = new SPWalletController();
                                $wallet = $spWalletController->debitSP( $task_assigned_to_user, $task->task_sp,
                                    [ 'transaction_title' => "task approved",
                                    'ref_table' => "task_assigned",
                                    'ref_table_id' => null,
                                    'description' => "$task->task_sp sp rewarded by claim of task id: $task->task_id"]);
                            }

                            $title = 'Task Approved';
                            $msg = $task->task_title.' task has been approved.';

                        } else {

                            $title = 'Task Rejected';
                            $msg = $task->task_title.' task has been rejected.';

                        }

                        $type = 'task_assigned';
                        $assignedUser = User::find($taskAssigned->user_id);
                        if($assignedUser->device_type == 'android'){
                           Helpers::sendPushAndroid(array($assignedUser->device_token), $title, $msg, $type, $task_assigned_id);
                        } else if($assignedUser->device_type == 'ios'){
                           Helpers::sendPushIOS(array($assignedUser->device_token), $title, $msg, $type, $task_assigned_id);
                        }
                        Helpers::storeNotifications($user->user_id, array($taskAssigned->user_id), $title, $msg, $type, $task_assigned_id);

                    }
                }

            }

        }

        return Helpers::responseMessage(200, 'Task status updated successfully.');

    }


    public function revoke_task_claim(Request $request){
        $validated = $request->validate([
            'task_id' => 'required',
        ]);

        $user = $request->user();

        $taskAssigned = TaskAssigned::where('task_id', $request->task_id)
            ->where('user_id', $user->user_id)
            ->first();
        $filesToBeDeleted = $taskAssigned->approval_files;
        $task = $taskAssigned->task();
        // Delete the files
        foreach ($filesToBeDeleted as $file) {
            $file->delete();
        }

        $taskAssigned->status='PENDING';
        $taskAssigned->task_details_for_approval=null;
        $result = $taskAssigned->save();

        unset($taskAssigned->approval_files);
        $taskAssigned['deleted_files'] = $filesToBeDeleted;


        if($result){
            $resData = ['task_assigned'=>$taskAssigned];
            return Helpers::successResponse($resData, 200, 'Get childs fetched successfully.');
        }
        else
            return Helpers::responseMessage(500, 'Task revoke failed.');
    }

    public function get_task_assigned_childs(Request $request)
    {
        $validated = $request->validate([
            'task_id' => 'required',
        ]);

        $user = $request->user();

        $taskAssignedUsers = TaskAssigned::select('task_assigned_id', 'users.user_id','users.full_name', DB::raw('CONCAT("'.Config::get('constants.app.api-profile-pic-thumb-url').'",profile_pic) as profile_pic'))
                                ->leftJoin('users', 'users.user_id', 'task_assigned.user_id')
                                ->where('task_id', $request->task_id)
                                ->where('task_assigned.status', 'PENDING_APPROVED')
                                ->get();

        $resData['data']['assign_to'] = $taskAssignedUsers;

        return Helpers::successResponse($resData, 200, 'Get childs fetched successfully.');


    }

    public static function getTaskForProduct($user, $activeStore, $product, $shouldReturnAssigneedTo){
        $user_id = $user->user_id;
        $product_id = $product->product_id;
        $group_id = $activeStore->group_id;

        $isOwner = Group::where('owner_user_id', $user->user_id)->count();

        $query = Task::where('product_id', $product_id)
            ->where('group_id', $group_id);
            if($isOwner == 0){
                $query->whereRaw("task_id IN (SELECT task_id FROM task_assigned WHERE task_id = tasks.task_id AND user_id = $user->user_id)");
            }
        $task =  $query->first();
        if(isset($task) && $shouldReturnAssigneedTo){
            $arrTaskAssignedTo = TaskAssigned::where('task_id', $task->task_id)
                    ->orderBy('created_at', 'desc')
                    ->limit(5)
                    ->get();
            $userIds = array();
            foreach($arrTaskAssignedTo AS $taskAssignedTo){
                $userIds[] = $taskAssignedTo->user_id;
            }
            $assignedToUsers = User::select('user_id','full_name','profile_pic', 'email', 'mobile')
                ->whereIn('user_id',$userIds)
                ->get();
            $task['assignedToUsers'] = $assignedToUsers;
        }
        return $task;
    }

    public function get_task_by_id(Request $request){
        $validated = $request->validate([
            'task_id' => 'required|numeric',
            'include_assigned_to' => 'boolean',
            'strict_assignee_check' => 'boolean',
            'include_linked_reward' => 'boolean',
            'include_goal' => 'boolean'
        ]);

        $task = Task::select('tasks.*', 'goals.goal_name')->leftJoin("goals", "tasks.goal_id", "=", "goals.goal_id")->find($request->task_id);
        if(!isset($task))
            return Helpers::responseMessage(404, 'task not found');

        //Populating assigned task to current user and other 5 users
        $user = $request->user();
        $user_task_assignment = TaskAssigned::where('task_id', $task->task_id)
            ->where('user_id', $user->user_id)
            ->first();
        if(!isset($user_task_assignment)){
            if($request->has('strict_assignee_check') && $request->strict_assignee_check){
                    return Helpers::responseMessage(404, 'task not assigned to the current user');
            }
        } else {
            $current_assigned_to_user = User::select('user_id','full_name','profile_pic', 'email', 'mobile')
                ->where('user_id',$user_task_assignment->user_id)
                ->first();
            $task['status'] = $user_task_assignment->status;
            $task['current_assigned_to_user'] = $current_assigned_to_user;
        }

        if($request->has('include_assigned_to') && $request->include_assigned_to){
            $arrTaskAssignedTo = TaskAssigned::where('task_id', $task->task_id)
                ->orderBy('created_at', 'desc')
                ->limit(5)
                ->get();
            $userIds = array();
            foreach($arrTaskAssignedTo AS $taskAssignedTo){
                $userIds[] = $taskAssignedTo->user_id;
            }
            $assignedToUsers = User::select('user_id','full_name','profile_pic', 'email', 'mobile')
                ->whereIn('user_id',$userIds)
                ->get();
            $task['assigned_to_users'] = $assignedToUsers;
        }

        //Populate Linked Reward
        if( $request->has('include_linked_reward') && $request->include_linked_reward
                && $task->task_type == 'ADDITIONAL_REWARD')
            if($task->product) $task->product->images;
        if($request->has('include_goal') && $request->include_goal)
            $task->goal;

        return Helpers::successResponse(['data' => $task], 200, "task fetched successfully" );
    }

    public function claim_task(Request $request){
        $validated = $request->validate([
            "task_id" => "required|numeric",
            /*"comments" => "string"*/
        ]);

        $user = $request->user();
        $comments = $request->comments;
        $activeStore = CommonController::getActiveStore($request);

        $task = Task::find([$request->task_id])->first();
        if(!isset($task)){
            Log::info("task_id $request->task_id not found");
            return Helpers::responseMessage(400, 'Task id provided is not present');
        }

        //Populating assigned task to current user and other 5 users
        $user_task_assignment = TaskAssigned::where('task_id', $task->task_id)
            ->where('user_id', $user->user_id)
            ->first();
        if(!isset($user_task_assignment)){
            return Helpers::responseMessage(400, 'task not assigned to the current user');
        } else if($user_task_assignment->status != 'PENDING'){
            return Helpers::responseMessage(400, 'Task can not be claimed, current status for the task is: '.$user_task_assignment->status);
        }
        $new_status = 'PENDING_APPROVED';
        $user_task_assignment->status = $new_status;
        $user_task_assignment->task_details_for_approval = $comments;
        $result = $user_task_assignment->save();
        if(!$result){
            return Helpers::responseMessage(500, 'failure while claiming the task');
        }

        if(isset($request->approval_files) && $request->hasFile('approval_files'))
        {
            $files = array();
            if(is_array($request->approval_files))
                $files = $request->file('approval_files');
            else{
                $files[] = $request->file('approval_files');
            }
            $saved_files = array();
            foreach($files AS $key => $file){
                $task_claimed_approval_file = $this->save_task_claimed_approval_file($user_task_assignment, $file);
                if(isset($task_claimed_approval_file))
                    $saved_files[] = $task_claimed_approval_file;
            }
        }

        $user_task_assignment->approval_files;
        return Helpers::successResponse(array('data'=>$user_task_assignment), 200, 'Claim submitted for review.');
    }

    private function save_task_claimed_approval_file(TaskAssigned $user_task_assignment, $file){
        $fileName = rand().time().'.'.$file->getClientOriginalExtension();

        // Save original size image
        $file->move(public_path('task_claim_files'), $fileName);

        $task_assignment_approval_file = TaskAssignedApprovalFile::insert(
            ['task_assigned_id' => $user_task_assignment->task_assigned_id,
            'file_name' => $fileName]);
        return $task_assignment_approval_file;
    }


}