RootZanli & NinjaCr3

: / home / o5t6x7pgljbm / public_html / admin / app / Http / Controllers / Api / V2 /
Filename : V2ParentController.php
back
<?php
namespace App\Http\Controllers\Api\V2;

use App\Libraries\Helpers;
use App\Models\Attendance\Attendance;
use App\Models\DynamicContent;
use App\Models\Product;
use App\Models\Task;
use App\Models\User;
use App\V2\Dtos\FilterClaimDTO;
use App\V2\Dtos\FilterRewardDTO;
use App\V2\Dtos\FilterTaskDTO;
use App\V2\Dtos\GetTaskDTO;
use App\V2\Resources\AttendanceResource;
use App\V2\Resources\ClaimResource;
use App\V2\Resources\GroupResource;
use App\V2\Resources\RewardResource;
use App\V2\Resources\TaskResource;
use App\V2\Resources\TUITTransactionResource;
use App\V2\Resources\UserActivityHistoryResource;
use App\V2\Services\AmazonProductService;
use App\V2\Services\AttendanceService;
use App\V2\Services\CalendarService;
use App\V2\Services\ClaimService;
use App\V2\Services\GoalService;
use App\V2\Services\GroupService;
use App\V2\Services\RewardService;
use App\V2\Services\TaskService;
use App\V2\Services\TUITService;
use App\V2\Services\UserActivityService;
use Carbon\Carbon;
use Exception;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Config;
use Illuminate\Support\Facades\DB;
use Storage;
class V2ParentController extends V2BaseController {

    private $taskService;
    private $taskResource;
    private $goalService;
    private $rewardService;
    private $rewardResource;
    private $claimService;
    private $claimResource;
    private $groupService;
    private $tuitService;
    private $userActivityService;
    private $groupResource;
    private $tuitTransactionResource;
    private $amazonProductService;

    function __construct(){
        parent::__construct();
        $this->taskService = new TaskService();
        $this->taskResource = new TaskResource();
        $this->goalService = new GoalService();
        $this->rewardService = new RewardService();
        $this->rewardResource = new RewardResource();
        $this->claimService = new ClaimService();
        $this->claimResource = new ClaimResource();
        $this->groupService = new GroupService();
        $this->tuitService = new TUITService();
        $this->groupResource = new GroupResource();
        $this->tuitTransactionResource = new TUITTransactionResource();
        $this->userActivityService = new UserActivityService();
    }

    private function getAmazonProductService(){
        Log::info("V2ParentController::getAmazonProductService()");
        if($this->amazonProductService == null)
            $this->amazonProductService = new AmazonProductService();
        return $this->amazonProductService;
    }

    function get_app_home_tasks(Request $request){
        Log::info("V2ParentController::get_app_home_tasks()");

        //Validations:

        //retrive contextual details:
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $response_data = array();

        $due_soon_limit = 10;
        $recommended_tasks_limit = 10;
        $active_tasks_limit = 10;

        $filterTaskDto = FilterTaskDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->getForGroupOrGlobal(true)
            ->requiredFor('PARENT')
            ->limit($due_soon_limit)
            ->shouldLoadAssigneeList(true)
            ->build();

        $due_soon_tasks = $this->taskService->getDueSoonTasks($filterTaskDto);
        $recommended_tasks = $this->taskService->getRecommendedTasks($filterTaskDto);
        $active_tasks = $this->taskService->getTasks($filterTaskDto);

        $response_data['due_soon_tasks'] = $this->taskResource->fromTaskstoArray($due_soon_tasks);
        $response_data['recommended_tasks'] = $this->taskResource->fromTaskstoArray($recommended_tasks);
        $response_data['goals'] = $this->goalService->getAllGoals();
        $response_data['active_tasks'] = $this->taskResource->fromTaskstoArray($active_tasks);

        return Helpers::successResponse(['data' => $response_data], 200, 'Data fetched successfully.');
    }

    function get_task_by_id(Request $request, $taskId){
        Log::info("V2ParentController::get_task_by_id()");
        //Input Validations - start
        $path_params = ['taskId' => $taskId];
        $error_if_any = Helpers::validatorErrorResponse(
            $request, $path_params, ['taskId' => 'required|numeric']);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        //Input Validations - end

        //Validate Data correctness - start
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);
        $getTaskDto = GetTaskDTO::builder()
            ->user($currentUser)->store($currentStore)->group($currentGroup)
            ->taskIds([$taskId])
            ->requiredFor('PARENT')
            ->getForGroupOrGlobal(true)
            ->build();
        //Validate Data correctness - end

        $response_data = array();

        try{
            $tasks = $this->taskService->getTasksById($getTaskDto);
            $response_data = $this->taskResource->fromTasktoArray($tasks[0]);
        }catch(Exception $e){
            return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
        }

        return Helpers::successResponse(['data' => $response_data], 200, 'Data fetched successfully.');
    }

    function list_tasks(Request $request){
        Log::info("V2ParentController::list_tasks()");
        //Input Validations - start
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'goal_id' => 'numeric',
                'listing_type' => ['string', 'in:'. implode(",", ['RECOMMENDED','RECURRING','CREATED_BY_PARENT']) ]
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

        //retrive contextual details:
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $limit = 10;
        $activeParentsInGroup = $this->groupService->getAllParents($currentGroup);
        $parent_ids = $activeParentsInGroup->pluck('user_id')->toArray();

        $filterTaskDto = FilterTaskDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->getForGroupOrGlobal(true)
            ->requiredFor('PARENT')
            ->limit($request->has('limit') ? $request->limit : $limit)
            ->page_no($request->has('page_no') ? $request->page_no : 1)
            ->goalId($request->has('goal_id') ? $request->goal_id : null)
            ->shouldLoadAssigneeList(true)
            ->shouldNotHaveProduct($request->has('product_mapped') ? $request->product_mapped : null)
            ->listing_type($request->has('listing_type') ? $request->listing_type : null)
            ->shouldBeRecommended($request->has('listing_type') && $request->listing_type == 'RECOMMENDED' ? true : null )
            ->created_by_ids($request->has('listing_type') && $request->listing_type == 'CREATED_BY_PARENT' ? $parent_ids : null)
            ->shouldBeRecurring($request->has('listing_type') && $request->listing_type == 'RECURRING' ? true : null )
            ->build();

        $active_tasks = $this->taskService->getTasks($filterTaskDto);
        $response_paginated_data = $this->taskResource->fromTaskstoArray($active_tasks, true);

        return Helpers::successResponse($response_paginated_data, 200, 'Data fetched successfully.');
    }

    function list_tasks_for_reward_mapping(Request $request){
        Log::info("V2ParentController::list_tasks_for_reward_mapping()");

        //Input Validations - start
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], []);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

        //retrive contextual details:
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $limit = 100;
        $activeParentsInGroup = $this->groupService->getAllParents($currentGroup);
        $parent_ids = $activeParentsInGroup->pluck('user_id')->toArray();

        $filterTaskDto = FilterTaskDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->getForGroupOrGlobal(true)
            ->requiredFor('PARENT')
            ->dueByGraterThan(Carbon::now()->subDays(1)->format('Y-m-d'))
            ->include_null_for_due_by(true)
            ->limit($request->has('limit') ? $request->limit : $limit)
            ->page_no($request->has('page_no') ? $request->page_no : 1)
            ->build();

        $active_tasks = $this->taskService->getTasks($filterTaskDto);
        $response_paginated_data = $this->taskResource->fromTaskstoArray($active_tasks, true);

        return Helpers::successResponse($response_paginated_data, 200, 'Data fetched successfully.');
    }

    function get_app_add_task_page(Request $request){
        Log::info("V2ParentController::get_app_add_task_page()");

        //retrive contextual details:
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $response_data = array();

        $recommended_tasks_limit = 10;
        $recurring_tasks_limit = 5;

        $filterTaskDto = FilterTaskDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->getForGroupOrGlobal(true)
            ->limit($recommended_tasks_limit)
            ->shouldLoadAssigneeList(true)
            ->build();

        $recurringTaskFilterDto = FilterTaskDTO::builder()->copyFrom($filterTaskDto)
            ->shouldBeRecurring(true)
            ->limit($recurring_tasks_limit)
            ->build();

        $recommended_tasks = $this->taskService->getRecommendedTasks($filterTaskDto);
        $recurring_tasks = $this->taskService->getRecurringTasks($recurringTaskFilterDto);

        $response_data['recommended_tasks'] = $this->taskResource->fromTaskstoArray($recommended_tasks);
        $response_data['recurring_tasks'] = $this->taskResource->fromTaskstoArray($recurring_tasks);
        $response_data['goals'] = $this->goalService->getAllGoals();

        return Helpers::successResponse(['data' => $response_data], 200, 'Data fetched successfully.');

    }

    public function create_tasks(Request $request){
        Log::info("V2ParentController::create_tasks()");

        //Input Validations - start
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'task_title' => 'required|string',
                'description' => 'required|string',
                'task_type' => ['string', 'in:'. implode(",", ['SCHOLARSHIP_POINTS','ADDITIONAL_REWARD']) ],
                'visible_to' => ['string', 'in:'. implode(",", ['GLOBAL','GLOBAL_FOR_PARENT'
                    ,'GLOBAL_FOR_PARENT_AND_CHILD','ZIPCODE_PARENT','ZIPCODE_PARENT_AND_CHILD'
                    ,'COUNTRY_PARENT','COUNTRY_PARENT_AND_CHILD','SELECTED_PARENT'])],
                'task_review_allowed_to_type' => ['string', 'in:'. implode(",", ['ADMIN','PARENTS_OR_FOSTER_AGENT','USERS'])],
                // 'task_img' => 'required',
                'assign_to' => 'required',
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        //Input Validations - end

        try{
            $response = DB::transaction(function() use($request){
                    [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);
                    $default_goal = $this->goalService->getDefaultGoal();

                    $task = [];
                    $task['parent_task_id'] = $request->has('parent_task_id') ?  $request->parent_task_id : null;
                    $task['group_id'] = $currentGroup->group_id;
                    $task['task_title'] = $request->task_title;
                    $task['description'] = $request->description;
                    $task['goal_id'] = $request->has('goal_id') ? $request->goal_id : $default_goal->goal_id;
                    $task['task_sp'] = $request->has('task_sp') ? $request->task_sp : 0;
                    $task['task_type'] = $request->has('task_type') ? $request->task_type :
                            ( $request->has('product_id') ? 'ADDITIONAL_REWARD' : 'SCHOLARSHIP_POINTS' );
                    $task['product_id'] = $request->has('product_id') && $request->product_id != 0 ? $request->product_id : null;
                    $task['due_by'] = $request->has('due_by') ? $request->due_by : null;
                    $task['task_status'] = $request->has('task_status') ? $request->task_status : 'ACTIVE';
                    $task['is_featured'] = $request->has('is_featured') ? $request->is_featured : 0;
                    $task['created_by'] = $currentUser->user_id;

                    $task_additional_details = [];
                    $task_additional_details['review_required'] = $request->has('review_required') ? $request->review_required : null;
                    $task_additional_details['repeate_after_days'] = $request->has('repeate_after_days') ? $request->repeate_after_days : null;
                    $task_visibility = [];
                    if($request->has('visible_to')){
                        $task_additional_details['visible_to'] = $request->has('visible_to') ? $request->visible_to : null;
                        if(in_array(strtoupper($request->visible_to), ['ZIPCODE_PARENT','ZIPCODE_PARENT_AND_CHILD'], true)){
                            $task_visibility['entity_type'] = 'ZIPCODE';
                            $task_visibility['entity_ids'] = is_array($request->visible_to_zipcode) ?
                                $request->visible_to_zipcode : explode(',', $request->visible_to_zipcode);
                        } else if(in_array(strtoupper($request->visible_to), ['SELECTED_PARENT'], true)) {
                            $task_visibility['entity_type'] = 'USER';
                            $task_visibility['entity_ids'] = is_array($request->visible_to_user_ids) ?
                                $request->visible_to_user_ids : explode(',', $request->visible_to_user_ids);
                        } else if(in_array(strtoupper($request->visible_to), ['COUNTRY_PARENT','COUNTRY_PARENT_AND_CHILD'], true)
                            && $request->has('visible_to_country')){
                            $task_visibility['entity_type'] = 'COUNTRY';
                            $task_visibility['entity_ids'] = is_array($request->visible_to_country) ?
                                $request->visible_to_country : explode(',', $request->visible_to_country);
                        }
                    }

                    $task_review_permission_details = [];
                    $task_additional_details['task_review_allowed_to_type_arr'] = [];
                    if($request->has('task_review_allowed_to_type')){
                        $task_review_allowed_to_type_arr = is_array($request->task_review_allowed_to_type) ? $request->task_review_allowed_to_type : explode(',', $request->task_review_allowed_to_type);
                        $task_additional_details['task_review_allowed_to_type'] = $request->task_review_allowed_to_type;
                        $task_additional_details['task_review_allowed_to_type_arr'] = $task_review_allowed_to_type_arr;
                        foreach($task_review_allowed_to_type_arr AS $task_review_allowed_to_type){
                            if($task_review_allowed_to_type == 'USER'){
                                $task_review_permission_details['user_id'] = $currentUser->user_id;
                                $task_review_permission_details['team_id'] = null;
                                $task_review_permission_details['entity_type'] = 'TASK';
                                $task_review_permission_details['entity_ids'] = is_array($request->task_review_allowed_to_user_ids) ?
                                $request->task_review_allowed_to_user_ids : explode(',', $request->task_review_allowed_to_user_ids);
                            }
                        }
                    } else {
                        $task_additional_details['task_review_allowed_to_type_arr'] = ['PARENTS_OR_FOSTER_AGENT'];
                    }

                    if ($request->hasFile('task_img')) {
                        $task_images = is_array($request->file('task_img')) ? $request->file('task_img') : [$request->file('task_img')];
                    } else {
                        $task_images = [];
                    }

                    $task_assignees_user_id_list = is_array($request->assign_to) ? $request->assign_to : explode(",",$request->assign_to);
                    //creating basic arrays for tasks related models - end

                    //save tasks details via task service
                    $task = $this->taskService->createTask($currentUser, $task, $task_assignees_user_id_list, $task_images,
                        $task_additional_details, $task_visibility, $task_review_permission_details, $currentGroup, $currentStore);

                    $product = null;
                    if($request->has('product_id') ){
                        try{
                            $old_product = Product::find($request->product_id);
                            if($old_product){
                                Log::debug("trying to clone product");
                                $product = $this->commonService->cloneProductAndAssociateToTask($task, $old_product,
                                    $currentUser, $currentGroup, $currentStore);
                            }
                            if($product){
                                Log::debug("Product clonned successfully");
                            }
                        }catch(Exception $e){
                            Log::error("exception occured while associating product to task: ". $e->getMessage());
                            Log::error($e->getTraceAsString());
                            throw $e;
                        }
                    }
                    $task = Task::find($task->task_id);
                    $task_arr = $this->taskResource->fromTasktoArray($task);
                    return Helpers::successResponse(['data' => $task_arr], 200, 'Task created successfully.');
            });
            return $response;

        }catch (Exception $e){
            Log::error("exception occured while adding task: ". $e->getMessage());
            Log::error($e->getTraceAsString());
            return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
        }

    }

    public function update_tasks(Request $request, $taskId){
        Log::info("V2ParentController::update_tasks()");

        $path_params = ['taskId' => $taskId];
        //Input Validations - start
        $error_if_any = Helpers::validatorErrorResponse(
            $request, $path_params, [
                'taskId' => 'required|numeric',
                'task_title' => 'string',
                'description' => 'string',
                'task_type' => ['string', 'in:'. implode(",", ['SCHOLARSHIP_POINTS','ADDITIONAL_REWARD']) ],
                // 'visible_to' => ['string', 'in:'. implode(",", ['GLOBAL','GLOBAL_FOR_PARENT','GLOBAL_FOR_PARENT_AND_CHILD','ZIPCODE_PARENT','ZIPCODE_PARENT_AND_CHILD','SELECTED_PARENT'])],
                // 'task_review_allowed_to_type' => ['string', 'in:'. implode(",", ['ADMIN','PARENTS_OR_FOSTER_AGENT','USERS'])],
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        //Input Validations - end

        try{
            $response = DB::transaction(function() use($request, $taskId){
                [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);
                $default_goal = $this->goalService->getDefaultGoal();

                $taskIdFilterDto = GetTaskDto::builder()->user($currentUser)
                    ->store($currentStore)->group($currentGroup)
                    ->taskIds([$request->task_id])->build();
                $task_obj = null;
                try{
                    $task_objs = $this->taskService->getTasksById($taskIdFilterDto);
                    $task_obj = $task_objs[0];
                } catch(Exception $e){
                    if($e->getCode() == 404)
                        return Helpers::responseMessage(404, 'Task not found');
                    else {
                        Log::error("Exception Occured", $e);
                        return Helpers::responseMessage(500, 'Internal Server Error');
                    }
                }
                $old_task_product_id = $task_obj->product_id;

                //creating basic arrays for tasks related models - start
                $task = [];
                $task['task_title'] = $request->has('task_title') ? $request->task_title : null;
                $task['description'] = $request->has('description') ? $request->description : null;
                $task['task_sp'] = $request->has('task_sp') ? $request->task_sp : null;
                $task['task_type'] = $request->has('task_type') ? $request->task_type :
                        ( $request->has('product_id') ? 'ADDITIONAL_REWARD' : null );
                $task['product_id'] = $request->has('product_id') ? $request->product_id : null;
                $task['due_by'] = $request->has('due_by') && !empty($request->due_by) ? $request->due_by : null;
                $task['task_status'] = $request->has('task_status') ? $request->task_status : null;
                $task['is_featured'] = $request->has('is_featured') ? $request->is_featured : null;

                $task_additional_details = [];
                $task_additional_details['review_required'] = $request->has('review_required') ? $request->review_required : null;
                $task_additional_details['repeate_after_days'] = $request->has('repeate_after_days') ? $request->repeate_after_days : null;
                $task_visibility = [];
                // if($request->has('visible_to')){
                //     $task_additional_details['visible_to'] = $request->has('visible_to') ? $request->visible_to : null;
                //     if(in_array(strtoupper($request->visible_to), ['ZIPCODE_PARENT','ZIPCODE_PARENT_AND_CHILD'], true)){
                //         $task_visibility['entity_type'] = 'ZIPCODE';
                //         $task_visibility['entity_ids'] = is_array($request->visible_to_zipcode) ?
                //             $request->visible_to_zipcode : explode(',', $request->visible_to_zipcode);
                //     } else if(in_array(strtoupper($request->visible_to), ['SELECTED_PARENT'], true)) {
                //         $task_visibility['entity_type'] = 'USER';
                //         $task_visibility['entity_ids'] = is_array($request->visible_to_user_ids) ?
                //             $request->visible_to_user_ids : explode(',', $request->visible_to_user_ids);
                //     }
                // }

                $task_review_permission_details = [];
                // if($request->has('task_review_allowed_to_type')){
                //     $task_additional_details['task_review_allowed_to_type'] = $request->task_review_allowed_to_type;
                //     if($request->task_review_allowed_to_type == 'USER'){
                //         $task_review_permission_details['user_id'] = $currentUser->user_id;
                //         $task_review_permission_details['team_id'] = null;
                //         $task_review_permission_details['entity_type'] = 'TASK';
                //         $task_review_permission_details['entity_ids'] = is_array($request->task_review_allowed_to_user_ids) ?
                //         $request->task_review_allowed_to_user_ids : explode(',', $request->task_review_allowed_to_user_ids);
                //     }
                // }
                // else {
                $task_additional_details['task_review_allowed_to_type_arr'] = ['PARENTS_OR_FOSTER_AGENT'];
                // }
                $task_images = isset($request->task_img) && $request->hasFile('task_img') ?
                        (is_array($request->file('task_img')) ? $request->file('task_img')
                        : [$request->file('task_img')]) : null;

                $task_assignees_user_id_list = [];
                if($request->has('add_assign_to'))
                    $task_assignees_user_id_list['add'] = is_array($request->add_assign_to) ? $request->add_assign_to : explode(",",$request->add_assign_to);
                if($request->has('remove_assign_to'))
                    $task_assignees_user_id_list['remove'] = is_array($request->remove_assign_to) ? $request->remove_assign_to : explode(",",$request->remove_assign_to);
                if($request->has('final_assign_to'))
                    $task_assignees_user_id_list['final'] = is_array($request->final_assign_to) ? $request->final_assign_to : explode(",",$request->final_assign_to);
                //creating basic arrays for tasks related models - end

                //save tasks details via task service
                $this->taskService->updateTask($currentUser, $task_obj, $task, $task_assignees_user_id_list, $task_images,
                    $task_additional_details, $task_visibility, $task_review_permission_details, $currentGroup, $currentStore);

                $product = null;
                if($request->has('product_id') && $request->product_id != $old_task_product_id){
                    try{
                        $old_product = Product::find($request->product_id);
                        if($old_product && $old_product->task_id != $taskId){
                            $product = $this->commonService->cloneProductAndAssociateToTask($task_obj, $old_product
                                , $currentUser, $currentGroup, $currentStore);
                        }
                    }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)
                    ||  $task_obj->product_id > 0) {
                    $attached_product = Product::where('product_id', $task_obj->product_id)->first();
                    $this->commonService->syncTaskVisibilityToProduct($task_obj, $attached_product);
                    $this->commonService->syncTaskExpiryToProduct($task_obj, $attached_product);
                    $this->commonService->syncTaskGroupToProduct($task_obj, $attached_product);
                }

                return Helpers::responseMessage(200, 'Task updated successfully.');
            });
            return $response;
        } catch(Exception $e){
            Log::error("exception occured while creating product: ". $e->getMessage());
            Log::error($e->getTraceAsString());
            return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
        }

    }

    public function get_app_home_rewards(Request $request){
        Log::info("V2ParentController::get_app_home_rewards()");

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $limit = 12;
        $response_data = array();
        $filterRewardDto = FilterRewardDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->limit($limit)
            ->requiredFor('PARENT')
            ->createdByIds([$currentUser->user_id, -1])
            ->orderByColumn('created_at')
            ->order('DESC')
            ->dueByGraterThan(Carbon::now()->subDays(1)->format('Y-m-d'))
            // ->status('ACTIVE')
            ->build();

        $latest_rewards_by_admin = $this->rewardService->getLatestRewardsByAdmin($filterRewardDto);
        $featured_rewards = $this->rewardService->getFeaturedRewards($filterRewardDto);
        $rewardsCreatedByYouDto = FilterRewardDTO::builder()
            ->copyFrom($filterRewardDto)
            ->createdByIds([$currentUser->user_id])
            ->build();
        $active_rewards = $this->rewardService->getRewards($rewardsCreatedByYouDto);

        $response_data['featured_rewards'] = $this->rewardResource->fromRewardsToArray($featured_rewards, false, false, null, false, $currentStore, $filterRewardDto);
        $response_data['latest_rewards_by_admin'] = $this->rewardResource->fromRewardsToArray($latest_rewards_by_admin,  false, false, null, false, $currentStore, $filterRewardDto);
        $response_data['reward_categories'] = $this->rewardService->getAllRewardCategories();
        $response_data['active_rewards'] = $this->rewardResource->fromRewardsToArray($active_rewards,  false, false, null, false, $currentStore, $filterRewardDto);

        return Helpers::successResponse(['data' => $response_data], 200, 'Data fetched successfully.');
    }

    public function get_app_family_store(Request $request) {
        Log::info("V2ParentController::get_app_family_store()");

        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'limit' => 'numeric',
                'page_no' => 'numeric',
                'category_id' => 'numeric',
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $limit = 12;
        $page_no = 1;
        $category_id = null;

        if($request->has('limit'))
            $limit = $request->limit;
        if($request->has('page_no'))
            $page_no = $request->page_no;
        if($request->has('category_id'))
            $category_id = $request->category_id;

        $response_data = array();
        $filterRewardDto = FilterRewardDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->limit(12)
            ->requiredFor('PARENT')
            ->orderByColumn('created_at')
            ->order('DESC')
            ->dueByGraterThan(Carbon::now()->subDays(1)->format('Y-m-d'))
            // ->status('ACTIVE')
            ->build();

        $featured_rewards = $this->rewardService->getFeaturedRewards($filterRewardDto);

        $filterBuilder = FilterRewardDTO::builder()->copyFrom($filterRewardDto);
        $filterBuilder = $filterBuilder->limit($limit)->page_no($page_no);
        if($category_id != null)
            $filterBuilder = $filterBuilder->category_id($category_id);

        $filterBuilder->only_visible_to_children(true);

        $filterRewardDto = $filterBuilder->build();

        $active_rewards = $this->rewardService->getRewards($filterRewardDto);

        $response_data['featured_rewards'] = $this->rewardResource->fromRewardsToArray($featured_rewards,  false, false, null, false, $currentStore, $filterRewardDto);
        $response_data['reward_categories'] = $this->rewardService->getAllRewardCategories();
        $response_data['active_rewards_paginated'] = $this->rewardResource->fromRewardsToArray($active_rewards, true,  false, null, false, $currentStore, $filterRewardDto);

        return Helpers::successResponse(['data' => $response_data], 200, 'Data fetched successfully.');
    }

    public function list_rewards(Request $request) {
        Log::info("V2ParentController::list_rewards()");

        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'limit' => 'numeric',
                'page_no' => 'numeric',
                'category_id' => 'numeric',
                'listing_type' => ['string', 'in:'. implode(",", ['LATEST','CREATED_BY_PARENT','INCLUDE_EXPIRED']) ]
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $limit = 12;
        $page_no = 1;
        $category_id = null;

        if($request->has('limit'))
            $limit = $request->limit;
        if($request->has('page_no'))
            $page_no = $request->page_no;
        if($request->has('category_id'))
            $category_id = $request->category_id;

        $activeParentsInGroup = $this->groupService->getAllParents($currentGroup);
        $parent_ids = $activeParentsInGroup->pluck('user_id')->toArray();

        $filterBuilder = FilterRewardDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->limit($limit)
            ->page_no($page_no)
            // ->store_id($currentStore->store_id)
            ->orderByColumn('created_at')
            ->requiredFor('PARENT')
            ->listing_type($request->has('listing_type') ? $request->listing_type : null)
            ->createdByIds($request->has('listing_type') && $request->listing_type == 'CREATED_BY_PARENT' ? $parent_ids : null )
            // ->status('ACTIVE')
            ->dueByGraterThan(Carbon::now()->subDays(1)->format('Y-m-d'))
            ->order('DESC');

        if($request->has('listing_type') && $request->listing_type == 'INCLUDE_EXPIRED'){
            $filterBuilder->dueByGraterThan(null);
        }
        if($category_id != null)
            $filterBuilder = $filterBuilder->category_id($category_id);

        $filterRewardDto = $filterBuilder->build();

        $active_rewards = $this->rewardService->getRewards($filterRewardDto);

        $paginated_response = $this->rewardResource->fromRewardsToArray($active_rewards, true, false, null, false, $currentStore, $filterRewardDto);

        return Helpers::successResponse($paginated_response , 200, 'Data fetched successfully.');
    }

    public function list_rewards_for_task_mapping(Request $request) {
        Log::info("V2ParentController::list_rewards_for_task_mapping()");

        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'limit' => 'numeric',
                'page_no' => 'numeric',
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $limit = 100;
        $page_no = 1;

        if($request->has('limit'))
            $limit = $request->limit;

        $filterBuilder = FilterRewardDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->limit($limit)
            ->page_no($page_no)
            // ->store_id($currentStore->store_id)
            ->orderByColumn('created_at')
            ->requiredFor('PARENT')
            ->dueByGraterThan(Carbon::now()->subDays(1)->format('Y-m-d'))
            ->order('DESC');

        $filterRewardDto = $filterBuilder->build();

        $active_rewards = $this->rewardService->getRewards($filterRewardDto);

        $paginated_response = $this->rewardResource->fromRewardsToArray($active_rewards, true, false, null, false, $currentStore, $filterRewardDto);

        return Helpers::successResponse($paginated_response , 200, 'Data fetched successfully.');
    }

    public function create_rewards(Request $request) {
        Log::info("V2ParentController::create_rewards()");

        //Input Validations - start
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'product_name' => 'required|string',
                'description' => 'required|string',
                // 'product_img' => 'required',
                'product_sp' => 'required',
                'is_featured' => 'boolean',
                'product_type' => ['string', 'in:'. implode(",", ['REWARD','GLOBAL']) ],
                'product_category_id'=>'required|numeric',
                'requirement_for_claim' => ['string', 'in:' . implode(",", ['SP', 'TASK', 'SP_OR_TASK', 'SP_AND_TASK'])]
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        try{
            $response = DB::transaction(function() use($request){
                //Input Validations - end
                [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);
                $default_goal = $this->goalService->getDefaultGoal();
                $task_id = $request->has('task_id') ? $request->task_id : null;
                $task = null;
                $getTaskDto = GetTaskDTO::builder()
                        ->user($currentUser)->store($currentStore)->group($currentGroup)
                        ->taskIds([$task_id])
                        ->requiredFor('PARENT')
                        ->build();

                $product = [];
                $product['parent_product_id'] = $request->has('parent_product_id') ? $request->parent_product_id : null;
                $product['product_name'] = $request->product_name;
                $product['description'] = $request->description;
                $product['product_sp'] = $request->product_sp;
                $product['product_category_id'] = $request->product_category_id;
                $product['product_type'] = $request->product_type;
                $product['group_id'] = $currentGroup->group_id;
                $product['expires_on'] = $request->has('expires_on') && !empty($request->expires_on) ? date('Y-m-d', strtotime($request->expires_on))  : null;
                $product['is_featured'] = $request->has('is_featured') ? $request->is_featured : 0;
                $product['latitude'] = $request->has('latitude') ? $request->latitude : null;
                $product['longitude'] = $request->has('longitude') ? $request->longitude : null;
                $product['status'] = $request->has('status') ? $request->status : 'ACTIVE';
                $product['created_by'] = $currentUser->user_id;
                if($task != null){
                    $product['task_id'] = $task->task_id;
                }
                if($product['expires_on'] == null){
                    unset($product['expires_on']);
                }

                if ($request->hasFile('product_img')) {
                    $product_images = is_array($request->file('product_img')) ? $request->file('product_img') : [$request->file('product_img')];
                } else {
                    $product_images = [];
                }

                $product_additional_details = [];
                $product_additional_details['requirement_for_claim'] = $request->has('requirement_for_claim') ? $request->requirement_for_claim : 0;
                $product_additional_details['max_claim_allowed_total'] = $request->has('max_claim_allowed_total') ? $request->max_claim_allowed_total : null;
                $product_additional_details['max_claim_allowed_per_user'] = $request->has('max_claim_allowed_per_user') ? $request->max_claim_allowed_per_user : null;
                $product_additional_details['visible_in_family_store'] = $request->has('visible_in_family_store') ? $request->visible_in_family_store : null;
                $product_additional_details['repeate_after_days'] = $request->has('repeate_after_days') ? $request->repeate_after_days : null;


                $product = $this->rewardService->createReward($currentUser, $product, $product_images, $product_additional_details, $currentGroup);
                $response_data = null;
                $task = null;
                if($request->has('task_id') ){
                    try{
                        $old_task = Task::find($request->task_id);
                        if($old_task){
                            $task = $this->commonService->cloneTaskAndAssociateToProduct($product, $old_task,
                                $currentUser, $currentGroup);
                        }
                    }catch(Exception $e){
                        Log::error("exception occured while associating task to product: ". $e->getMessage());
                        Log::error($e->getTraceAsString());
                        throw $e;
                    }
                }
                $this->rewardService->loadAdditionalInfo([$product], $getTaskDto);
                $response_data = $this->rewardResource->fromRewardToArray($product, true, null, false, $currentStore, null);
                return Helpers::successResponse(['data' => $response_data], 200, 'Reward created successfully.');
            });
            return $response;
        } catch(Exception $e){
            Log::error("exception occured while creating product: ". $e->getMessage());
            Log::error($e->getTraceAsString());
            return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
        }
    }

    public function update_rewards(Request $request, $productId) {
        Log::info("V2ParentController::update_rewards()");

        //Input Validations - start
        $path_params = ['productId' => $productId];
        $error_if_any = Helpers::validatorErrorResponse(
            $request, $path_params, [
                'productId' => 'required|numeric',
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        //Input Validations - end
        try{
            $response = DB::transaction(function() use($request, $productId){
                [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);
                $rewards = $this->rewardService->getRewardById($productId);
                $reward_obj = null;
                if($rewards != null && count($rewards) > 0){
                    $reward_obj = $rewards[0];
                } else {
                    return Helpers::responseMessage(404, 'Reward not found');
                }
                $task_id = $request->has('task_id') ? $request->task_id : null;
                $old_product_task_id = $reward_obj->task_id;
                $product = [];
                $product['product_name'] = $request->has('product_name') ? $request->product_name : null;
                $product['description'] = $request->has('description') ? $request->description : null;
                $product['product_sp'] = $request->has('product_sp') ? $request->product_sp : null;
                $product['product_category_id'] = $request->has('product_category_id') ? $request->product_category_id : null;
                $product['product_type'] = $request->has('product_type') ? $request->product_type : null;
                $product['expires_on'] = $request->has('expires_on') && !empty($request->expires_on) ? date('Y-m-d', strtotime($request->expires_on))  : null;
                $product['is_featured'] = $request->has('is_featured') ? $request->is_featured : null;
                $product['latitude'] = $request->has('latitude') ? $request->latitude : null;
                $product['longitude'] = $request->has('longitude') ? $request->longitude : null;
                $product['status'] = $request->has('status') ? $request->status : null;

                $product_images = $request->hasFile('product_img') ?
                    ( is_array($request->file('product_img')) ? $request->file('product_img')
                        : [$request->file('product_img')]) : null;

                $product_additional_details = [];
                $product_additional_details['requirement_for_claim'] = $request->has('requirement_for_claim') ? $request->requirement_for_claim : null;
                $product_additional_details['max_claim_allowed_total'] = $request->has('max_claim_allowed_total') ? $request->max_claim_allowed_total : null;
                $product_additional_details['max_claim_allowed_per_user'] = $request->has('max_claim_allowed_per_user') ? $request->max_claim_allowed_per_user : null;
                $product_additional_details['visible_in_family_store'] = $request->has('visible_in_family_store') ? $request->visible_in_family_store : null;
                $product_additional_details['repeate_after_days'] = $request->has('repeate_after_days') ? $request->repeate_after_days : null;

                $product = $this->rewardService->updateReward($currentUser, $reward_obj, $product, $product_images, $product_additional_details);

                $task = null;
                if($request->has('task_id') && $request->task_id != $old_product_task_id){
                    try{
                        $old_task = Task::find($request->task_id);
                        if($old_task && $old_task->product_id != $productId){
                            $task = $this->commonService->cloneTaskAndAssociateToProduct($reward_obj, $old_task,
                                $currentUser, $currentGroup);
                        }
                    }catch(Exception $e){
                        Log::error("exception occured while associating task to product: ". $e->getMessage());
                        Log::error($e->getTraceAsString());
                        throw $e;
                    }
                } else if( ($request->has('task_id') && $request->task_id == $old_product_task_id)
                    ||  $reward_obj->task_id > 0) {
                    $attached_task = Task::where('task_id', $reward_obj->task_id)->first();
                    if($attached_task != null){
                        $this->commonService->syncProductVisibilityToTask($reward_obj, $attached_task);
                        $this->commonService->syncProductExpiryToTask($reward_obj, $attached_task);
                        $this->commonService->syncProductGroupToTask($reward_obj, $attached_task);
                    }
                }

                return Helpers::responseMessage(200, 'Reward updated successfully.');
            });
            return $response;
        } catch(Exception $e){
            Log::error("exception occured while updating product: ". $e->getMessage());
            Log::error($e->getTraceAsString());
            return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
        }

    }

    public function get_reward_by_id(Request $request, $productId){
        Log::info("V2ParentController::get_reward_by_id()");

        //Input Validations - start
        $path_params = ['productId' => $productId];
        $error_if_any = Helpers::validatorErrorResponse(
            $request, $path_params, ['productId' => 'required|numeric']);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        //Input Validations - end

        //Validate Data correctness - start
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);
        $getRewardDto = FilterRewardDTO::builder()
            ->user($currentUser)->store($currentStore)->group($currentGroup)
            ->rewardIds([$productId])
            ->requiredFor('PARENT')
            ->build();
        //Validate Data correctness - end

        $response_data = array();

        try{
            $rewards = $this->rewardService->getRewards($getRewardDto);
            if($rewards == null || count($rewards) <= 0){
                return Helpers::responseMessage( 404, 'Reward not found');
            }
            $load_full_details = true;
            $response_data = $this->rewardResource->fromRewardToArray($rewards[0], $load_full_details, null, false, $currentStore, $getRewardDto);
        }catch(Exception $e){
            Log::error("exception occured while taking attendence: ". $e->getMessage());
            Log::error($e->getTraceAsString());
            return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
        }

        return Helpers::successResponse(['data' => $response_data], 200, 'Data fetched successfully.');

    }

    public function publish_reward_for_child(Request $request, $productId){
        Log::info("V2ParentController::publish_reward_for_child()");


        //Input Validations - start
        $path_params = ['productId' => $productId];
        $error_if_any = Helpers::validatorErrorResponse(
            $request, $path_params, [
                'productId' => 'required|numeric',
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        //Input Validations - end
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

    }

    public function get_claims(Request $request){
        Log::info("V2ParentController::get_claims()");

        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'limit' => 'numeric',
                'page_no' => 'numeric',
        ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $limit = 12;
        $page_no = 1;
        $status_list = ['PENDING_APPROVAL', 'APPROVED', 'REDEEMED'];

        if($request->has('limit'))
            $limit = $request->limit;
        if($request->has('page_no'))
            $page_no = $request->page_no;
        if($request->has('status')){
            $status_list = is_array($request->status) ? $request->status : [$request->status];
        }

        $filterDto = FilterClaimDTO::builder()
            ->user($currentUser)->store($currentStore)->group($currentGroup)
            ->requiredFor('PARENT')
            ->statusList($status_list)
            ->orderByColumn('created_at')
            ->order('DESC')
            ->page_no($page_no)
            ->limit($limit)
            ->build();
            //TODO, only return for those tasks for which this user is allwed to review
        $claims = $this->claimService->getClaimsForGroup($filterDto);
        $response_data = $this->claimResource->fromClaimsToArray($claims, true, true);
        return Helpers::successResponse($response_data, 200, 'Claims retrieved successfully.');
    }

    public function update_claim(Request $request, $claimId){
        Log::info("V2ParentController::gpdate_claim()");

        $error_if_any = Helpers::validatorErrorResponse(
            $request, ['claimId' => $claimId], [
                'claimId' => 'required|numeric',
                'new_status' => [ 'required', 'string', 'in:'. implode(",", ['APPROVED','REJECTED']) ],
        ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $filterDto = FilterClaimDTO::builder()
            ->user($currentUser)->store($currentStore)->group($currentGroup)
            ->requiredFor('PARENT')
            ->claimIds([$claimId])
            ->orderByColumn('created_at')
            ->order('DESC')
            ->build();
        $claims = $this->claimService->getClaimsForGroup($filterDto);
        if(count($claims) == 0){
            return Helpers::responseMessage( 404, 'Claim not found');
        }
        $claim = $claims[0];
        $canReview = $this->claimService->canReviewTaskClaim(
                $currentUser, $currentGroup, $currentStore, $claim);
        if(!$canReview){
            return Helpers::responseMessage( 403, 'Not enough permission to review the claim');
        }
        $claim = $this->claimService->changeClaimStatus($currentUser,
            $currentGroup, $currentStore, $claim, $request->new_status);

        $response_data = $this->claimResource->fromClaimToArray($claim, true);
        return Helpers::successResponse($response_data, 200, 'Claims updated successfully.');
    }

    public function publish_reward_to_children(Request $request){
        Log::info("V2ParentController::publish_reward_to_children()");

        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'reward_id' => 'required|numeric',
        ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        try{
            $result = $this->rewardService->publishReward($currentUser, $currentGroup,
                $currentStore, $request->reward_id);
            return Helpers::responseMessage( 200, 'Reward successfully published to the store');

        }catch(Exception $e) {
            Log::error("exception occured while publishing rewards: ". $e->getMessage());
            Log::error($e->getTraceAsString());
            return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
        }
    }

    public function unpublish_reward_to_children(Request $request){
        Log::info("V2ParentController::unpublish_reward_to_children()");

        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'reward_id' => 'required|numeric',
        ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        try{
            $result = $this->rewardService->unpublishReward($currentUser, $currentGroup,
                $currentStore, $request->reward_id);
                return Helpers::responseMessage( 200, 'Reward successfully unpublished from the store');

        }catch(Exception $e) {
            Log::error("exception occured while unpublishing reward: ". $e->getMessage());
            Log::error($e->getTraceAsString());
            return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
        }

    }

    public function getUserDashboardForApp(Request $request){
        Log::info("V2ParentController::getUserDashboardForApp()");


        $today_obj = $request->has('today') && !empty($request->today)
            ? new Carbon($request->today) : Carbon::today();

        Log::debug("Current Date from Client: ". $today_obj);
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);
        $membership_groups = $currentUser->membershipGroups;
        $owning_groups = $currentUser->owningGroups;
        $combined_groups = [];
        if($membership_groups == null || empty($membership_groups)){
            $combined_groups = $owning_groups;
        } else if ($owning_groups == null || empty($owning_groups)){
            $combined_groups = $membership_groups;
        } else {
            // Log::debug('combining groups');
            $combined_groups = $membership_groups->merge($owning_groups)->keyBy('group_id')->values();
        }

        $current_user_arr = $currentUser->only(['user_id', 'full_name', 'uuid', 'profile_pic', 'email', 'mobile']);

        $tuit_wallet = $this->tuitService->getTUITWallet($currentUser);
        $tuit_usd_balance = $this->tuitService->getTUIT_To_USDT($tuit_wallet['balance']);
        $tuit_last_transactions = $this->tuitService->getTUITLatestTransactions($currentUser, 1);
        $tuit_last_transaction = !empty($tuit_last_transactions) && count($tuit_last_transactions) > 0
            ? $tuit_last_transactions[0] : null;

        $paginated_tasks = $this->getFilteredTasks($currentUser, $currentStore, $currentGroup, $request);
        $paginated_rewards = $this->getFilteredRewards($currentUser, $currentStore, $currentGroup, $request);
        $paginated_claims = $this->getFilteredClaims($currentUser, $currentStore, $currentGroup, $request, ['PENDING_APPROVAL']);
        $num_active_tasks = $paginated_tasks->total();
        $num_active_rewards = $paginated_rewards->total();
        $num_pending_claims = $paginated_claims->total();
        // $activity_histories = $this->userActivityService->getLatestActivityHistory(
        //     $currentUser->user_id, [-1, $currentGroup->group_id], 10, 1);
        $activity_histories = $this->userActivityService->getLatestActivityHistory(
            $currentUser->user_id, [], 10, 1);
        $dynamic_banner_content = DynamicContent::
                            where('content_key', DynamicContent::KEY_PARENT_HOME_SCREEN_BANNER)
                            ->first();
        $dynamic_banner_on_click_link = DynamicContent::
                            where('content_key', DynamicContent::KEY_PARENT_HOME_SCREEN_BANNER_ON_CLICK_LINK)
                            ->first();
        $latest_activity_history = $this->commonService->getHasNewActivity($currentUser, $currentGroup);
        if($latest_activity_history != null)
            $this->commonService->updateLatestViewedActivityHistory($currentUser, $currentGroup, $latest_activity_history);

        //Attendance Details
        $attendance_details_user_wise = $this->getUserWiseCalendarAttendancesInGroup($currentGroup,
        (new Carbon($today_obj))->subDays(9)->startOfDay(),
        (new Carbon($today_obj))->endOfDay());

        $response_data = [];
        $response_data['current_group'] = $this->groupResource->fromGroupToArray($currentGroup, false);
        $response_data['all_groups'] = $this->groupResource->fromGroupsToArray($combined_groups, false, false);
        $response_data['current_user'] = $current_user_arr;
        $response_data['latest_tuit_wallet_transaction'] = $this->tuitTransactionResource->fromTUITTransactionToArray($tuit_last_transaction);
        $response_data['tuit_balance_details'] = [
                'tuit_balance' => Helpers::formatDecimanPointsTUIT($tuit_wallet['balance']),
                'usd_balance' => Helpers::formatDecimanPointsTUIT($tuit_usd_balance),
                'tuit_balance_str' => number_format(Helpers::formatDecimanPointsTUIT($tuit_wallet['balance']), 3) ." TUIT",
                'usd_balance_str' => "$" . number_format(Helpers::formatDecimanPointsTUIT($tuit_usd_balance), 2) . " ~"];
        $response_data['attendance_details'] = $attendance_details_user_wise;
        $response_data['active_tasks'] = ['count' => $num_active_tasks];
        $response_data['active_rewards'] = ['count' => $num_active_rewards];
        $response_data['pending_claims'] = ['count' => $num_pending_claims];
        $response_data['banner_url'] = $dynamic_banner_content != null ? $dynamic_banner_content->content_value : '';
        $response_data['banner_on_click_link'] = $dynamic_banner_on_click_link != null ? $dynamic_banner_on_click_link->content_value : '';
        $response_data['activity_history'] = !empty($activity_histories)
            ? (new UserActivityHistoryResource())->fromUserActivityHistoriesToArray($activity_histories, false)
            : null;
        $response_data['today_ymdhis'] = date('Y-m-d h:i:s');
        $response_data['has_new_activity_history'] = false;
        $response_data['my_issued_documents'] = null;
        $response_data['certificate_authorities'] = null;

        return Helpers::successResponse(['data' => $response_data], 200, 'Dashboard Details retrieved successfully.');
    }

    public function getTUITDashboardForApp(Request $request){
        Log::info("V2ParentController::getTUITDashboardForApp()");

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);
        $tuit_wallet_arr = $this->tuitService->getTUITWallet($currentUser);
        $tuit_balance = number_format(Helpers::formatDecimanPointsTUIT($tuit_wallet_arr['balance']), 3);
        $amount = $this->tuitService->getTUIT_To_USDT($tuit_balance);
        $amount = number_format($amount, 2);

        $response_data = [];
        $response_data['tuit_wallet'] = [];
        $response_data['tuit_wallet']['tuit_balance'] = $tuit_balance;
        $response_data['tuit_wallet']['tuit_balance_str'] = $tuit_balance ." TUIT";
        //TODO: to be retrieved from external api
        $response_data['tuit_wallet']['amount'] = $amount;
        $response_data['tuit_wallet']['amount_str'] = '$'. $amount;
        $response_data['tuit_wallet']['user_full_name'] = $currentUser->full_name;
        $response_data['tuit_wallet']['user_uuid'] = $currentUser->uuid;

        return Helpers::successResponse($response_data, 200, 'TUIT Dashboard Details retrieved successfully.');
    }

    public function getHasNewActivity(Request $request){
        Log::info("V2ParentController::getHasNewActivity()");

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);
        $latest_activity_history = $this->commonService->getHasNewActivity($currentUser, $currentGroup);
        return Helpers::successResponse(['data' => ['has_new_activity_history' => $latest_activity_history != null ? true : false]]
            , 200, 'Details retrieved successfully.');
    }

    private function getFilteredTasks($currentUser, $currentStore, $currentGroup, $request){
        Log::info("V2ParentController::getFilteredTasks()");

        $filterTaskDto = FilterTaskDTO::builder()
        ->user($currentUser)
        ->store($currentStore)
        ->group($currentGroup)
        ->getForGroupOrGlobal(true)
        ->requiredFor('PARENT')
        ->limit(1)
        ->page_no(1)
        // ->only_count(true)
        ->build();

        $active_tasks = $this->taskService->getTasks($filterTaskDto);
        return $active_tasks;
    }

    private function getFilteredRewards($currentUser, $currentStore, $currentGroup, $request){
        Log::info("V2ParentController::getFilteredRewards()");

        $filterBuilder = FilterRewardDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->limit(1)
            ->page_no(1)
            // ->store_id($currentStore->store_id)
            ->requiredFor('PARENT')
            ->dueByGraterThan(Carbon::now()->subDays(1)->format('Y-m-d'))
            ->order('DESC');

        $filterRewardDto = $filterBuilder->build();
        $active_rewards = $this->rewardService->getRewards($filterRewardDto);
        return $active_rewards;
    }

    private function getFilteredClaims($currentUser, $currentStore, $currentGroup, $request, $status_list){
        $filterDto = FilterClaimDTO::builder()
            ->user($currentUser)->store($currentStore)->group($currentGroup)
            ->requiredFor('PARENT')
            ->statusList($status_list)
            ->page_no(1)
            ->limit(1)
            ->build();
        $claims = $this->claimService->getClaimsForGroup($filterDto);
        return $claims;
    }

    public function search_rewards_from_amazon(Request $request){
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'q' => 'required|string',
                'limit' => 'numeric',
                'page_no' => 'numeric',
        ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $searchKeyword = $request->q;
        $limit = $request->has('limit') ? $request->limit : 10;
        $response_json = $this->getAmazonProductService()->searchProducts($searchKeyword, $limit);

        return Helpers::successResponse(['data' => $response_json], 200, 'reward details retrieved successfully.');
    }

    public function get_children_attendance(Request $request){
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'month' => 'required_without:from_date|date_format:Y-m',
                'from_date' => 'required_without:month|required_with:to_date|date_format:Y-m-d',
                'to_date' => 'required_with:from_date|date_format:Y-m-d'
        ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $from_date = null;
        $to_date = null;
        if($request->has('month')){
            //month format
            $date = Helpers::getFirstDateOfMonth($request->month);
            $carbonDate = Carbon::instance($date);
            $from_date = $carbonDate->startOfMonth()->startOfDay();
            $to_date = $carbonDate->endOfMonth()->endOfDay();
        } else if($request->has('from_date') && $request->has('to_date') ){
            $from_date = Carbon::createFromFormat('Y-m-d', $request->from_date)->startOfDay();
            $to_date = Carbon::createFromFormat('Y-m-d', $request->to_date)->endOfDay();
        }

        $response_json = [];
        $response_json['attendance_details'] = $this->getUserWiseCalendarAttendancesInGroup($currentGroup, $from_date, $to_date);
        return Helpers::successResponse(['data' => $response_json], 200, 'reward details retrieved successfully.');
    }

    public function update_children_attendance(Request $request){
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'user_id' => 'required|string',
                'date' => 'required|date_format:Y-m-d',
                'present' => 'required|boolean',
        ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        if(!$this->getCalendarService()->isWorkingDayForGroup($currentGroup, $request->date)){
            return Helpers::responseMessage( 400, "{$request->date} is holiday, can not take attendence" );
        }

        $user = User::where('user_id', $request->user_id)->first();
        if(!$user){
            return Helpers::responseMessage( 400, "user not found with {$request->user_id}" );
        }

        $existing_attendance = Attendance::where('user_id', $user->user_id)
            ->where('date', $request->date)
            ->whereNotIn('attendance_updated_by_type', ['CHILD','PARENT'])
            ->first();

        if($existing_attendance != null){
            return Helpers::responseMessage( 400, "can not change attendance, as it is already updated by Admin" );
        }

        $result = false;
        try{
            $result = $this->getAttendanceService()->updateAttendance($currentGroup, $user, $request->date, $request->present, 'PARENT', $currentUser->user_id);
        } catch(Exception $e){
            Log::error("exception occured while taking attendence: ". $e->getMessage());
            Log::error($e->getTraceAsString());
            $result = false;
        }

        if(!$result){
            return Helpers::responseMessage( 500, "error in taking attendence, please try again later.." );
        }
        $from_date = Carbon::createFromFormat('Y-m-d', $request->date)->startOfDay();
        $to_date = Carbon::createFromFormat('Y-m-d', $request->date)->endOfDay();
        $response_json = [];

        $response_json['attendance_details'] = $this->getUserWiseCalendarAttendancesInGroup($currentGroup, $from_date, $to_date);

        return Helpers::successResponse(['data' => $response_json], 200, 'attendence updated successfully.');
    }

    public function update_multi_children_attendance(Request $request){
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'date' => 'required|date_format:Y-m-d'
        ]);
        if($error_if_any['flag'] != 0){
            // Log::debug("Validation response: ". print_r($error_if_any, true));
            return $error_if_any['response'];
        }
        // Log::debug("Request for Update Multi Children attendance: ". print_r($request->all(), true));

        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        if(!$this->getCalendarService()->isWorkingDayForGroup($currentGroup, $request->date)){
            return Helpers::responseMessage( 400, "{$request->date} is holiday, can not take attendence" );
        }

        $warnings = [];
        if($request->has('user_ids')){
            $user_ids = is_array($request->user_ids) ? $request->user_ids : [$request->user_ids];
            $existing_user_ids_collection = User::whereIn('user_id', $user_ids)->pluck('user_id');
            if(!$existing_user_ids_collection){
                return Helpers::responseMessage( 400, "users not found with user ids: ". print_r($user_ids, true) );
            }
            $existing_user_ids = $existing_user_ids_collection->toArray();

            $non_existing_user_ids = array_diff($user_ids, $existing_user_ids);
            if(!empty($non_existing_user_ids)){
                return Helpers::responseMessage( 400, "users not found with user ids: ". print_r($non_existing_user_ids, true) );
            }

            $new_existing_user_ids = $this->getAttendanceService()->getChangableAttendanceUserIds($currentGroup->group_id, $existing_user_ids, $request->date, 'PARENT');

            if(count($new_existing_user_ids) != count($existing_user_ids)){
                $warnings[] = 'Attendance of few users can not be updated, as it is already updated by Admin.';
            }

            $result = false;
            try{
                $result = $this->getAttendanceService()->updateMultipleUserAttendance($currentGroup, $existing_user_ids, $request->date, 'PARENT', $currentUser->user_id);
            } catch(Exception $e){
                Log::error("exception occured while taking attendence: ". $e->getMessage());
                Log::error($e->getTraceAsString());
                $result = false;
            }
        }
        else{
            try{
                $existing_attendance_to_be_absent = Attendance::select('user_id')
                        ->whereIn('group_id', [-1, $currentGroup->group_id])
                        ->where('date', $request->date)
                        ->pluck('user_id')
                        ->toArray();
                $new_existing_user_ids = $this->getAttendanceService()->getChangableAttendanceUserIds($currentGroup->group_id, $existing_attendance_to_be_absent, $request->date, 'PARENT');

                if(count($new_existing_user_ids) != count($existing_attendance_to_be_absent)){
                    $warnings[] = 'Attendance of few users can not be updated, as it is already updated by Admin.';
                }
                $final_user_ids_to_be_absent = array_diff($existing_attendance_to_be_absent, $new_existing_user_ids);

                $result = $this->getAttendanceService()->updateMultipleUserAttendance($currentGroup, [], $request->date,'PARENT', $currentUser->user_id, $final_user_ids_to_be_absent);
            } catch(Exception $e){
                Log::error("exception occured while taking attendence: ". $e->getMessage());
                Log::error($e->getTraceAsString());
                $result = false;
            }
        }

        if(!$result){
            // Log::debug("result: ". $result);
            return Helpers::responseMessage( 500, "error in taking attendence, please try again later.." );
        }
        $from_date = Carbon::createFromFormat('Y-m-d', $request->date)->startOfDay();
        $to_date = Carbon::createFromFormat('Y-m-d', $request->date)->endOfDay();
        $response_json = [];

        $response_json['attendance_details'] = $this->getUserWiseCalendarAttendancesInGroup($currentGroup, $from_date, $to_date);

        $message = 'attendence updated successfully.';
        if(count($warnings) > 0){
            $message = implode(', ', $warnings);
        }
        // Log::debug("Final message: ". $message);
        return Helpers::successResponse(['data' => $response_json], 200, $message );
    }

}
?>