RootZanli & NinjaCr3

: / home / o5t6x7pgljbm / public_html / admin / app / Http / Controllers / Admin /
Filename : TaskController.php
back
<?php

namespace App\Http\Controllers\Admin;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use App\Models\Country;
use App\Models\CustomField;
use App\Models\Product;
use App\Models\Group;
use App\Models\Goal;
use App\Models\Task;
use App\Models\TaskSetting;
use App\Models\TaskVisibility;
use App\Models\TaskImage;
use App\Models\User;
use App\Models\PermissionUserEntity;
use App\Models\Permission;
use App\Models\TaskReviewAllowed;
use App\V2\Services\CommonService;
use App\V2\Services\TaskService;
use Auth;
use Hash;
use Session;
use DB;
use Exception;
use Socialite;
use Image;
Use Response;
use Helpers;
use File;
use Illuminate\Support\Facades\Log;
// use Str;
use Illuminate\Support\Str;

class TaskController extends Controller
{
    private $commonService;
    public function __construct(){
        $this->commonService = new CommonService();
    }
    public function index()
    {
        $tasks = Task::get();
        $groups = Group::get();
        $goals = Goal::get();
        $task_filter_options = Helpers::getFilterOptionsForTasksFromSession();
        return view('Admin.Task.index',compact('tasks','groups','goals','task_filter_options'));
    }

    public function getNewCFSection(Request $request){
        $new_counter = $request->new_counter;
        $cf_id = "new_$new_counter";
        return view('Admin.Task.custom_field_add_edit', compact('cf_id'));
    }

    public function task_list(Request $request)
    {
        $columns = array("t_id","task_title","group_name","goal_name","task_sp","task_type","product_name","due_by","visible_to","is_featured","task_id","uuid");
        $columns2 =array("tasks.task_id as t_id","tasks.task_title","groups.group_name","goals.goal_name","tasks.task_sp","tasks.task_type","products.product_name","tasks.due_by","task_settings.visible_to","tasks.is_featured","tasks.task_id","tasks.uuid");

        $totalData = Task::count();
        $limit = $request->input('length');
        $start = $request->input('start');

        $dir   = $request->input('order.0.dir');

        $query = Task::select($columns2)
        ->leftjoin('groups','groups.group_id','=','tasks.group_id')
        ->leftjoin('goals','goals.goal_id','=','tasks.goal_id')
        ->leftjoin('task_settings','task_settings.task_id','=','tasks.task_id')
        ->leftjoin('products','products.product_id','=','tasks.product_id');

        if (!empty($request->input('search.value'))) {
            $search = $request->input('search.value');
            $query->where(function ($query2) use ($columns2, $search) {
                foreach ($columns2 as $key => $value) {

                    if ($key == 0) {
                        $query2->orWhere('tasks.task_id','LIKE',"%{$search}%");
                    } else {
                        $query2->orWhere($value,'LIKE',"%{$search}%");
                    }
                }
                return $query2;
            });
        }

        $group_id = $request->group_id;
        $goal_id = $request->goal_id;
        $task_type = $request->task_type;
        $visible_to = $request->visible_to;
        Helpers::updateFilterOptionsForTasksInSession($group_id, $goal_id, $task_type, $visible_to);

        // ------------------------------
        if (!empty($group_id)) { $query->where('groups.group_id', $group_id); }
        if (!empty($goal_id)) { $query->where('goals.goal_id', $goal_id); }
        if (!empty($task_type)) { $query->where('tasks.task_type', $task_type); }
        if (!empty($visible_to)) { $query->where('task_settings.visible_to', $visible_to); }

        $tasks = $query->get();
        $totalFiltered = $tasks->count();

        $tasks = $query->offset($start);
        $tasks = $query->limit($limit);
        if(isset($columns2[$request->input('order.0.column')])){
            $order = $columns[$request->input('order.0.column')];
            $tasks = $query->orderBy($order,$dir);
        }
        if(isset($request->sort_by) && $request->sort_by == 1)
            $tasks = $query->orderBy('tasks.created_at', 'asc');
        else
            $tasks = $query->orderBy('tasks.created_at', 'desc');

        $tasks = $query->get();

        //$totalFiltered = $query->count();

        $data = array();
        if(!empty($tasks)) {
            foreach ($tasks as $key => $task) {
                $edit   = route('tasks.edit',$task->task_id);
                $delete = route('tasks.destroy', $task->task_id);

                $nestedData['task_details'] = Str::limit($task->task_title, '40', '...') .'</br><small style="color:lightgray">'.$task->uuid."</small>";
                foreach ($columns as $key => $column) {

                    if ($column == 'task_id') {
                        $nestedData[$column] = "<form action='{$delete}' method='POST'
                                                    id='taskTable-".$task->$column."'>
                                                    <input name='_method' type='hidden' value='DELETE'>
                                                    <a href='{$edit}' title='EDIT' class='mb-6 btn-floating waves-effect waves-light gradient-45deg-green-teal gradient-shadow'>
                                                    ".csrf_field()."
                                                    <i class='material-icons'>edit</i></a>
                                                    <button type='button' title='DELETE' class='mb-6 btn-floating waves-effect waves-light gradient-45deg-purple-deep-orange gradient-shadow' onclick='delete_task(".$task->$column.");'>
                                                        <i class='material-icons'>clear</i>
                                                    </button>
                                                </form>";
                    }
                    else if ($column == 't_id') {
                        $nestedData[$column] = '<label>
                                                    <input type="checkbox" class="checked-task-ids" value="'.$task->$column.'">
                                                    <span></span>
                                                </label>';
                    }
                    else if($column == 'created_at') {
                         $nestedData[$column] = date('j M Y h:i a',strtotime($task->$column)) ;
                    }
                    else if($column == 'due_by') {
                        $nestedData[$column] = $task->$column != null ? date('d M Y',strtotime($task->$column)): 'Expiry Not Set';
                    }
                    else if($column == 'task_title') {
                        $nestedData[$column] = Str::limit($task->task_title, '20', '...');
                    }
                    else if($column == 'product_name') {
                        $nestedData[$column] = Str::limit($task->product_name, '20', '...');
                    }
                    else if ($column == 'is_featured' && $task->is_featured == 1) {
                        $nestedData[$column] = '
                                        <div class="switch">
                                            <label>
                                                <input type="checkbox" class="chkbox" data-task-id="'.$task->task_id.'" value="'.$task->$column.'" style="border-style: solid;" checked>
                                                <span class="lever"></span>
                                            </label>
                                        </div>';
                    }
                    else if($column == 'is_featured' && $task->is_featured == 0){
                        $nestedData[$column] = '
                                    <div class="switch">
                                       <label>
                                            <input type="checkbox" class="chkbox" data-task-id="'.$task->task_id.'" value="'.$task->$column.'" style="border-style: solid;">
                                            <span class="lever"></span>
                                        </label>
                                   </div>';
                    }
                    else {
                        $nestedData[$column] = $task->$column;
                    }
                }
                $data[] = $nestedData;
            }
        }
        //echo count($data);exit;

        $json_data = array(
                    "draw"            => intval($request->input('draw')),
                    "recordsTotal"    => intval($totalData),
                    "recordsFiltered" => intval($totalFiltered),
                    "data"            => $data
                    );
        // echo '<pre>';print_r($json_data);die;
        echo json_encode($json_data);
    }

    public function is_featured(Request $request)
    {
        Task::where('task_id', $request->task_id)->update([
          'is_featured' => $request->is_featured,
        ]);
        echo $request->is_featured;exit;
        return response()->json(['success'=>'Status change successfully.']);
    }

    public function create()
    {
        $groups = Group::get();
        $goals = Goal::get();
        $products = Product::where('created_by', -1)
            // ->where('expires_on', '>=', DB::raw("'".date('Y-m-d')."'"))
            ->get();
        $users = User::get();
        $countries = Country::get();

        return view('Admin.Task.create',compact('products','groups','goals','products','users','countries'));
    }

    public function store(Request $request)
    {
        $validate = $request->validate([
            'group_id' => 'required_if:visible_to,',
            'task_title' => 'required',
            'goal_id' => 'required',
            'task_sp' => 'required',
            'task_type' => 'required',
            // 'product_id' => 'required',
            // 'due_by' => 'required',
        ]);

        try{
            $response = DB::transaction(function() use($request){
                $request['due_by'] = $request->has('due_by') && trim($request->due_by) != '' ?  date("Y-m-d", strtotime($request['due_by'])) : null;
                $request['uuid'] = Str::uuid()->toString();

                if($request->visible_to != '')
                    $request['group_id'] = null;

                if($request->has('repeate_after_days') && $request->repeate_after_days > 0){
                    $request['is_repeated'] = 1;
                }
                $tasks = Task::create($request->all());

                $permission = Permission::select('id')->where('name', 'TASK_REVIEW')->first();

                $request_task_review_allowed_to_type = $request->task_review_allowed_to_type;
                $task_review_allowed_to_type_arr = [];
                if(is_array($request_task_review_allowed_to_type)){
                    $task_review_allowed_to_type_arr = $request_task_review_allowed_to_type;
                } else{
                    $task_review_allowed_to_type_arr = explode(",", $request_task_review_allowed_to_type);
                }
                $task_review_allowed_to_type_first = $task_review_allowed_to_type_arr[0];

                if ($permission) {
                    $permission_id = $permission->id;
                    $task_id = $tasks->task_id;

                    foreach($task_review_allowed_to_type_arr AS $task_review_allowed_to_type){
                        if ($task_review_allowed_to_type == "USER") {
                            DB::table('permission_user_entity')->insert([
                                'permission_id' => $permission_id,
                                'user_id' => $request->user_id,
                                'entity_id' => $task_id,
                            ]);
                        }
                    }
                }

                $taskSettingId = TaskSetting::insertGetId([
                                    'task_id'            => $tasks->task_id,
                                    'visible_to'         => $request->visible_to,
                                    'review_required'    => $request->has('review_required') && $request->review_required != null
                                        ? $request->review_required : false,
                                    'repeate_after_days' => $request->has('repeate_after_days') && $request->repeate_after_days != '' ? $request->repeate_after_days : 0,
                                    'task_review_allowed_to_type' => $task_review_allowed_to_type_first,
                                ]);
                $taskSetting = TaskSetting::find($taskSettingId);

                $taskService = new TaskService();
                $taskService->saveTaskReviewAllowed( $tasks->task_id, $taskSetting->task_settings_id, $task_review_allowed_to_type_arr);

                $country_name_single = [];
                if($request->has('country_name_single') && is_array($request->country_name_single) && count($request->country_name_single) > 0
                    && in_array($request->visible_to, ["ZIPCODE_PARENT", "ZIPCODE_PARENT_AND_CHILD"])){
                    $country_name_single = $request->country_name_single;
                }

                $zipcode = $request->zipcode;
                if (!empty($zipcode) && is_string($zipcode) && in_array($request->visible_to, ["ZIPCODE_PARENT", "ZIPCODE_PARENT_AND_CHILD"] )) {
                    $entity_values = explode(",", trim($zipcode));
                }

                if(!empty($request->entity_value) && in_array($request->visible_to, ["SELECTED_PARENT"] )){
                    $entity_values = $request->entity_value;
                }

                if($request->has('country_name') && is_array($request->country_name) && count($request->country_name) > 0
                    && in_array($request->visible_to, ["COUNTRY_PARENT", "COUNTRY_PARENT_AND_CHILD"])){
                    $entity_values = $request->country_name;
                }


                if(isset($entity_values)){
                    foreach($entity_values as $entity_value){
                        TaskVisibility::insert([
                            'task_settings_id' => $taskSetting->task_settings_id,
                            'entity_type'  => ( in_array($request->visible_to, ["ZIPCODE_PARENT", "ZIPCODE_PARENT_AND_CHILD"] ) ? "ZIPCODE"
                                    : ( in_array($request->visible_to, ["SELECTED_PARENT"] ) ? "USER"
                                    : ( in_array($request->visible_to, ["COUNTRY_PARENT", "COUNTRY_PARENT_AND_CHILD"]) ? "COUNTRY"
                                    : null)
                                    )),
                            'entity_value' => $entity_value,
                        ]);
                    }
                }

                if(isset($country_name_single) && count($country_name_single) > 0){
                    TaskVisibility::insert([
                        'task_settings_id' => $taskSetting->task_settings_id,
                        'entity_type'  => 'COUNTRY_SINGLE',
                        'entity_value' => $country_name_single[0],
                    ]);
                }

                if($request->hasFile('taskImage'))
                {
                    $files = $request->file('taskImage');

                    foreach($files as $key => $file){

                        $imageName = rand().time().'.'.$file->extension();
                        // Save thumbnail image
                        $img = Image::make($file->getRealPath());

                        $img->resize(100, 100, function($constraint){

                            $constraint->aspectRatio();

                        })->save(public_path('/task_images/thumb/').$imageName);

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

                        TaskImage::insert([
                            'task_id' => $tasks->task_id,
                            'image_name' => $imageName
                        ]);
                    }
                }
                else{
                    TaskImage::insert([
                        'task_id' => $tasks->task_id,
                        'image_name' => 'default-task-image-color.jpg',
                    ]);
                }

                [$update_cf_data, $new_cf_data] = $this->getCustomField($request);

                if(!empty($new_cf_data)){
                    foreach($new_cf_data AS $cf_data){
                        CustomField::create([
                            'entity_type' => 'TASK',
                            'entity_id' => $tasks->task_id,
                            'field_type' => $cf_data['field_type'],
                            'field_name' => $cf_data['field_name'],
                            'field_label' => $cf_data['field_label'],
                            'data' => $cf_data['field_data']
                        ]);
                    }
                }

                $attached_product = null;
                if($request->has('product_id') ){
                    try{
                        $old_product = Product::find($request->product_id);
                        if($old_product){
                            $attached_product = $this->commonService->cloneProductAndAssociateToTask($tasks, $old_product);
                        }
                    }catch(Exception $e){
                        Log::error("exception occured while associating product to task: ". $e->getMessage());
                        Log::error($e->getTraceAsString());
                        // return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
                    }
                }

                $product_id = $request->product_ids;
                if($request->is_created === 'editProduct'){

                    return redirect()->route('products.edit',['product' => $product_id,'task_id' => $tasks->task_id]);
                }

                if($request->is_created == 'product'){
                    return redirect()->route('products.create',['task_id' => $tasks->task_id]);
                }
                else{
                    return redirect()->route('tasks.index')->with('success','Record Successfully Inserted.');
                }
            });
            return $response;
        }catch (Exception $e){
            Log::error("exception occured while creating task: ". $e->getMessage());
            Log::error($e->getTraceAsString());
            return redirect()->route('tasks.index')->with('error','create failed. check logs for more details');
        }
    }

    private function getCustomField(Request $request){
        $update_cf_data = [];
        $new_cf_data = [];
        foreach($request->all() AS $key => $value){
            $cf_id = null;
            $cf_key = null;
            if(str_starts_with($key, 'field_type_')){
                $cf_id = explode('field_type_', $key)[1];
                $cf_key = 'field_type';
            } else if(str_starts_with($key, 'field_name_')){
                $cf_id = explode('field_name_', $key)[1];
                $cf_key = 'field_name';
            } else if(str_starts_with($key, 'field_label_')){
                $cf_id = explode('field_label_', $key)[1];
                $cf_key = 'field_label';
            } else if(str_starts_with($key, 'field_data_')){
                $cf_id = explode('field_data_', $key)[1];
                $cf_key = 'field_data';
            }
            if($cf_id != null){
                if(str_starts_with($cf_id, 'new')){
                    if(!isset($new_cf_data[$cf_id]))
                        $new_cf_data[$cf_id] = [];
                    $new_cf_data[$cf_id][$cf_key] = $value;
                } else {
                    if(!isset($update_cf_data[$cf_id]))
                        $update_cf_data[$cf_id] = [];
                    $update_cf_data[$cf_id][$cf_key] = $value;
                }
            }
        }
        return [$update_cf_data, $new_cf_data];
    }

    public function edit($id)
    {
        $tasks = Task::find($id);
        $products = Product::where('created_by', -1)
            // ->where('expires_on', '>=', DB::raw("'". date('Y-m-d h:i:s') ."'"))
            ->get();
        $groups = Group::get();
        $goals = Goal::get();

        $users = User::get();
        $attached_product = $tasks->product_id != null ? Product::find($tasks->product_id) : null;
        if($attached_product != null){
            $has_product = false;
            foreach($products As $product){
                if($product->product_id == $attached_product->product_id){
                    $has_product = true;
                }
            }
            if(!$has_product){
                $products->prepend($attached_product);
            }
        }

        $permission_user = Task::select('permission_user_entity.user_id')
        ->leftjoin('permission_user_entity','permission_user_entity.entity_id','=','tasks.task_id')
        ->where('permission_user_entity.entity_id',$id)
        ->where('permission_user_entity.permission_id',5)
        ->first();

        // dd($permission_user);

        $taskSetting = TaskSetting::where('task_settings.task_id',$id)->first();
        // dd($taskSetting->task_setting_id);

        if (!empty($taskSetting->task_settings_id)) {
            $taskVisibility = TaskVisibility::where('task_settings_id',$taskSetting->task_settings_id)->get();
        }

        $commaSeparatedValues = '';
        $selectParent = null;
        $country_name_single = '';

        if (!empty($taskSetting) && ($taskSetting->visible_to == "SELECTED_PARENT")) {
            $selectParent = $taskVisibility;
        }

        if (!empty($taskSetting) && ($taskSetting->visible_to == "ZIPCODE_PARENT" || $taskSetting->visible_to == "ZIPCODE_PARENT_AND_CHILD")) {
            $commaSeparatedValues = $taskVisibility->filter(function($item) {
                return $item->entity_type === 'ZIPCODE';
            })->pluck('entity_value')->implode(',');
            $country_name_single = $taskVisibility->filter(function($item) {
                return $item->entity_type === 'COUNTRY_SINGLE';
            })->pluck('entity_value')->implode(',');
        }

        $countries = Country::get();

        $taskImages = TaskImage::where('task_id',$id)->get();

        return view('Admin.Task.edit',compact('tasks','groups','products','goals','taskSetting','taskImages','users','selectParent','commaSeparatedValues','permission_user', 'countries', 'country_name_single'));
    }

    public function update(Request $request,$id)
    {
        $validate = $request->validate([
            'group_id' => 'required',
            'task_title' => 'required',
            'goal_id' => 'required',
            'task_sp' => 'required',
            'task_type' => 'required',
            // 'product_id' => 'required',
            // 'due_by' => 'required',
        ]);

        try{
            $response = DB::transaction(function() use ($request, $id){
                $request_task_review_allowed_to_type = $request->task_review_allowed_to_type;
                $task_review_allowed_to_type_arr = [];
                if(is_array($request_task_review_allowed_to_type)){
                    $task_review_allowed_to_type_arr = $request_task_review_allowed_to_type;
                } else{
                    $task_review_allowed_to_type_arr = explode(",", $request_task_review_allowed_to_type);
                }
                $task_review_allowed_to_type_first = $task_review_allowed_to_type_arr[0];

                $tasks = Task::find($id);
                $old_task_product_id = $tasks->product_id;
                if($request->visible_to != '')
                    $request['group_id'] = null;
                // dd($request->all());
                $request['due_by'] = $request->has('due_by') && trim($request->due_by) != '' ? date("Y-m-d", strtotime($request['due_by'])) : null;

                if($request->task_type == 'SCHOLARSHIP_POINTS'){
                    $request['product_id'] = NULL;
                }
                // $request['due_by'] = date("Y-m-d", strtotime($request['due_by']));
                $request['is_featured'] = $request->is_featured;

                $attached_product = null;

                if($request->has('repeate_after_days') && $request->repeate_after_days > 0){
                    $request['is_repeated'] = 1;
                } else {
                    $request['is_repeated'] = 0;
                }
                $tasks->update($request->all());

                $permission = Permission::select('id')->where('name', 'TASK_REVIEW')->first();

                if ($permission) {
                    $permission_id = $permission->id;
                    foreach($task_review_allowed_to_type_arr AS $task_review_allowed_to_type){
                        if ($task_review_allowed_to_type == "USER") {
                            PermissionUserEntity::updateOrCreate(
                                ['entity_id' => $id],
                                [
                                    'permission_id' => $permission_id,
                                    'user_id' => $request->user_id,
                                    'entity_id' => $id,
                                ]
                            );
                        }
                    }

                }

                $taskSetting = TaskSetting::where('task_id',$tasks->task_id)->first();

                $taskSetting = TaskSetting::updateOrCreate(
                    ['task_id' => $tasks->task_id],
                    [
                        'visible_to'         => $request->visible_to,
                        'review_required'    => $request->has('review_required') && $request->review_required != null
                        ? $request->review_required : false,
                        'repeate_after_days' => $request->repeate_after_days,
                        'task_review_allowed_to_type' => $task_review_allowed_to_type_first,
                    ]
                );
                $taskService = new TaskService();
                $taskService->saveTaskReviewAllowed( $tasks->task_id, $taskSetting->task_settings_id, $task_review_allowed_to_type_arr);

                $zipcode = $request->zipcode;
                if (!empty($zipcode) && is_string($zipcode) && in_array($request->visible_to, ["ZIPCODE_PARENT", "ZIPCODE_PARENT_AND_CHILD"] )) {
                    $entity_values = explode(",", trim($zipcode));
                }

                $country_name_single = [];
                if($request->has('country_name_single') && is_array($request->country_name_single) && count($request->country_name_single) > 0
                    && in_array($request->visible_to, ["ZIPCODE_PARENT", "ZIPCODE_PARENT_AND_CHILD"])){
                    $country_name_single = $request->country_name_single;
                }

                if($request->has('country_name') && is_array($request->country_name) && count($request->country_name) > 0
                    && in_array($request->visible_to, ["COUNTRY_PARENT", "COUNTRY_PARENT_AND_CHILD"])){
                    $entity_values = $request->country_name;
                }

                if (!empty($request->entity_value) && $request->visible_to == "SELECTED_PARENT") {
                    $entity_values = $request->entity_value;
                }

                DB::table('task_visibility')->where('task_settings_id', $taskSetting->task_settings_id)->delete();

                if(isset($entity_values)){
                    foreach($entity_values as $entity_value){
                        TaskVisibility::insert(
                            [
                                'task_settings_id' => $taskSetting->task_settings_id,
                                'entity_type'  => ( in_array($request->visible_to, ["ZIPCODE_PARENT", "ZIPCODE_PARENT_AND_CHILD"] ) ? "ZIPCODE"
                                        : ( in_array($request->visible_to, ["SELECTED_PARENT"] ) ? "USER"
                                        : ( in_array($request->visible_to, ["COUNTRY_PARENT", "COUNTRY_PARENT_AND_CHILD"]) ? "COUNTRY"
                                        : null)
                                        )),
                                'entity_value' => $entity_value,
                            ]
                        );
                    }
                }

                if(isset($country_name_single) && count($country_name_single) > 0){
                    TaskVisibility::insert([
                        'task_settings_id' => $taskSetting->task_settings_id,
                        'entity_type'  => 'COUNTRY_SINGLE',
                        'entity_value' => $country_name_single[0],
                    ]);
                }

                if($request->hasFile('taskImage'))
                {
                    $files = $request->file('taskImage');

                    foreach($files as $key => $file){

                        $imageName = rand().time().'.'.$file->extension();

                        // Save thumbnail image
                        $img = Image::make($file->getRealPath());

                        $img->resize(100, 100, function($constraint){

                        $constraint->aspectRatio();

                        })->save(public_path('/task_images/thumb/').$imageName);

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

                        DB::table('task_images')->insert([
                            'task_id' => $id,
                            'image_name' => $imageName
                        ]);
                    }
                }
                else{
                    $check_task_images = TaskImage::where('task_id',$id)->exists();

                    if(!$check_task_images){
                        TaskImage::insert([
                            'task_id' => $id,
                            'image_name' => 'default-task-image-color.jpg',
                        ]);
                    }
                }

                $custom_fields = $tasks->customFields;
                $existing_ids = !empty($custom_fields) ? $custom_fields->pluck('custom_field_id')->toArray() : [];
                [$update_cf_data, $new_cf_data] = $this->getCustomField($request);
                // Log::debug("Request Input Params: ". print_r($request->all(), true));
                // Log::debug("Custom Fields Data: ". print_r([compact('update_cf_data', 'new_cf_data')], true));

                if(!empty($new_cf_data)){
                    foreach($new_cf_data AS $cf_data){
                        CustomField::create([
                            'entity_type' => 'TASK',
                            'entity_id' => $tasks->task_id,
                            'field_type' => $cf_data['field_type'],
                            'field_name' => $cf_data['field_name'],
                            'field_label' => $cf_data['field_label'],
                            'data' => $cf_data['field_data']
                        ]);
                    }
                }
                if(!empty($update_cf_data)){
                    $to_be_updated_cf_ids = array_keys($update_cf_data);
                    $to_be_deleted_cf_ids = array_diff($existing_ids, $to_be_updated_cf_ids);
                    foreach($update_cf_data AS $cf_id => $cf_data){
                        $custom_field = CustomField::where('custom_field_id', $cf_id)->first();
                        $custom_field->field_name = $cf_data['field_name'];
                        $custom_field->field_label = $cf_data['field_label'];
                        $custom_field->data=$cf_data['field_data'];
                        $custom_field->save();
                    }
                    if(!empty($to_be_deleted_cf_ids)){
                        CustomField::whereIn('custom_field_id', $to_be_deleted_cf_ids)->delete();
                    }
                }

                if($request->has('product_id') && $request->product_id != $old_task_product_id){
                    try{
                        $old_product = Product::find($request->product_id);
                        if($old_product){
                            $attached_product = $this->commonService->cloneProductAndAssociateToTask($tasks, $old_product);
                            $request['product_id'] = $attached_product->product_id;
                        }
                    }catch(Exception $e){
                        Log::error("exception occured while associating product to task: ". $e->getMessage());
                        Log::error($e->getTraceAsString());
                        throw $e;
                    }
                }else if( ($request->has('product_id') && $request->product_id == $old_task_product_id && $request->product_id != null)
                    ||  $tasks->product_id > 0) {
                    $attached_product = Product::where('product_id', $tasks->product_id)->first();
                    if($attached_product != null){
                        $this->commonService->syncTaskVisibilityToProduct($tasks, $attached_product);
                        $this->commonService->syncTaskExpiryToProduct($tasks, $attached_product);
                        $this->commonService->syncTaskGroupToProduct($tasks, $attached_product);
                    }
                }
                if($attached_product != null){
                    Log::debug("Clonned product id:" . $attached_product->product_id);
                    $tasks->product_id = $attached_product->product_id;
                    $tasks->save();
                }

                return redirect()->route('tasks.index')->with('success','Record Updated Successfully.');
            });
            return $response;
        }catch (Exception $e){
            Log::error("exception occured while updating task: ". $e->getMessage());
            Log::error($e->getTraceAsString());
            return redirect()->route('tasks.index')->with('error','Update failed. check logs for more details');
        }
    }

    public function destroy($id)
    {
        $data = Task::find($id)->delete();

        return redirect()->route('tasks.index')->with('success','Record Deleted Successfully');
    }

    public function delete_img(Request $request)
    {
        $taskImageId = $request->taskImageId;
        // $productImageName = $request->productImageName;

        TaskImage::where('task_image_id',$taskImageId)->delete();

        // File::delete(public_path('/product_images/thumb/'.$productImageName));
        // File::delete(public_path('/product_images/'.$productImageName));
    }

    public function fetchSP(Request $request)
    {
        $goal = Goal::where('goal_id', $request->goal_id)->first();
        $sp = $goal->scholarship_points;

        echo $sp;
    }

    function selected_tasks_action(Request $request)
    {
        if(!is_array($request->task_ids) && $request->task_ids == 'all'){
           $tasks = Task::get();
        } else {
           $tasks = Task::whereIn('task_id', $request->task_ids)->get();
        }
        // echo "<pre>";
        // print_r($tasks);

        if($request->flag == 'send_custom_template_task')
        {
            $tasks->each(function ($task) use ($request) {
                $task->update([
                    'task_sp' => $request->task_sp,
                ]);
            });
        }
        else if($request->flag == 'set_goal')
        {
            $tasks->each(function ($task) use ($request) {
                $task->update([
                    'goal_id' => $request->goal_id,
                ]);
            });
        }
        else if($request->flag == 'set_is_featured')
        {
            $tasks->each(function ($task) use ($request) {
                $task->update([
                    'is_featured' => $request->is_featured,
                ]);
            });
        }
        else if($request->flag == 'set_dueby')
        {

            $dueDate = strtotime($request->dueby);
            if ($dueDate !== false) {
                $dueDate = date("Y-m-d", $dueDate);
                $tasks->each(function ($task) use ($dueDate) {
                    $task->update([
                        'due_by' => $dueDate,
                    ]);
                });
            }
        }
        else if($request->flag == 'delete_task')
        {
            $tasks->each(function ($task) {
                $task->delete();
            });
        }
        else if($request->flag == 'set_repeate_task')
        {
            $task_settings = TaskSetting::whereIn('task_id', $request->task_ids)->get();

            $task_settings->each(function ($task_setting) use ($request) {
                $task_setting->update([
                    'repeate_after_days' => $request->repeate_tasks,
                ]);
            });
        }
        else if($request->flag == 'set_review_allowed')
        {
            $task_settings = TaskSetting::whereIn('task_id', $request->task_ids)->get();

            $task_settings->each(function ($task_setting) use ($request) {
                $task_setting->update([
                    'task_review_allowed_to_type' => $request->review_allowed,
                ]);
            });
        }
        else if($request->flag == 'set_visible_to')
        {
            $task_settings = TaskSetting::whereIn('task_id', $request->task_ids)->get();

            $task_settings->each(function ($task_setting) use ($request) {
                $task_setting->update([
                    'visible_to' => $request->visible_to,
                ]);
            });
        }
    }

}