RootZanli & NinjaCr3

: / home / o5t6x7pgljbm / public_html / admin / app / Http / Controllers / Api / V2 /
Filename : V2ChildController.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\User;
use App\V2\Dtos\FilterClaimDTO;
use App\V2\Dtos\FilterRewardDTO;
use App\V2\Dtos\FilterTaskDTO;
use App\V2\Dtos\GetTaskDTO;
use App\V2\Dtos\WishlistFilterDTO;
use App\V2\Resources\ClaimResource;
use App\V2\Resources\GroupResource;
use App\V2\Resources\RewardResource;
use App\V2\Resources\SPWalletTransactionResource;
use App\V2\Resources\TaskResource;
use App\V2\Resources\UserActivityHistoryResource;
use App\V2\Resources\WishlistResource;
use App\V2\Services\ClaimService;
use App\V2\Services\GoalService;
use App\V2\Services\RewardService;
use App\V2\Services\SPWalletService;
use App\V2\Services\TaskService;
use App\V2\Services\UserActivityService;
use App\V2\Services\WishlistService;
use Carbon\Carbon;
use Exception;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;

class V2ChildController extends V2BaseController {

    private $taskService;
    private $taskResource;
    private $goalService;
    private $rewardService;
    private $rewardResource;
    private $wishlistService;
    private $claimService;
    private $claimResource;
    private $wishlistResource;
    private $spWalletService;
    private $userActivityService;
    private $groupResource;
    private $spWalletTransactionResource;

    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->wishlistService = new WishlistService();
        $this->claimService = new ClaimService();
        $this->claimResource = new ClaimResource();
        $this->wishlistResource = new WishlistResource();
        $this->spWalletService = new SPWalletService();
        $this->userActivityService = new UserActivityService();
        $this->groupResource = new GroupResource();
        $this->spWalletTransactionResource = new SPWalletTransactionResource();
    }

    function get_app_home_tasks(Request $request){
        Log::info("V2ChildController::get_app_home_tasks()");
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'limit' => 'numeric',
                'page_no' => 'numeric',
                'goal_id' => 'numeric',
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

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

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

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

        $response_data = array();

        $filterTaskDto = FilterTaskDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->getForGroupOrGlobal(true)
            ->requiredFor('CHILD')
            ->limit(12)
            ->shouldLoadAssigneeList(true)
            ->orderByColumn('due_by')
            ->order('ASC')
            ->build();

        $due_soon_tasks = $this->taskService->getDueSoonTasks($filterTaskDto);
        $today = Carbon::now();
        $today_str = $today->format('Y-m-d');
        $filterTaskDto = FilterTaskDTO::builder()->copyFrom($filterTaskDto)
            ->page_no($page_no)
            ->limit($limit)
            ->goalId($goal_id)
            ->include_null_for_due_by(true)
            ->dueByGraterThan($today_str)
            ->build();
        $active_tasks = $this->taskService->getTasks($filterTaskDto);

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

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

    }

    function get_task_by_id(Request $request, $taskId){
        Log::info("V2ChildController::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('CHILD')
            ->getForGroupOrGlobal(true)
            ->build();
        //Validate Data correctness - end

        $response_data = array();

        try{
            $tasks = $this->taskService->getTasksById($getTaskDto);
            if($tasks == null || count($tasks) == 0){
                return Helpers::responseMessage( 404, 'Task not found');
            }
            $isTaskVisible = $this->taskService->isTaskVisibleForChild( $currentUser, $tasks[0]);
            if($tasks[0]->getTaskAssignedForUser($currentUser->user_id) == null && !$isTaskVisible){
                return Helpers::responseMessage( 400, 'Task is not assigned to the current user' );
            }
            $response_data = $this->taskResource->fromTasktoArray($tasks[0], $currentUser);
        }catch(Exception $e){
            Log::error($e->getTraceAsString());
            return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
        }

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

    public function get_app_store_rewards(Request $request){
        Log::info("V2ChildController::get_app_store_rewards()");
        $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)
            ->requiredFor('CHILD')
            ->limit(12)
            ->loadWishListInfo(true)
            ->orderByColumn('created_at')
            ->order('DESC')
            // ->status('ACTIVE')
            ->dueByGraterThan(Carbon::now()->subDays(1)->format('Y-m-d'))
            ->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);

        $filterRewardDto = $filterBuilder->build();

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

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

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

    public function get_app_family_store(Request $request){
        Log::info("V2ChildController::get_app_family_store()");
        $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;

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

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

        $filterRewardDto = $filterBuilder->build();

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

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

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

    function get_app_my_assigned_tasks(Request $request){
        Log::info("V2ChildController::get_app_my_assigned_tasks()");
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'limit' => 'numeric',
                'page_no' => 'numeric',
                'goal_id' => 'numeric',
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

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

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

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

        $today = Carbon::now();
        $today_str = $today->format('Y-m-d');

        $filterTaskDto = FilterTaskDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->page_no($page_no)
            ->limit($limit)
            ->dueByGraterThan($today_str)
            ->requiredFor('CHILD')
            ->goalId($goal_id)
            ->orderByColumn('due_by')
            ->order('ASC')
            ->getForGroupOrGlobal(false)
            ->shouldLoadAssigneeList(true)
            ->include_null_for_due_by(true)
            ->build();

        $my_assigned_tasks = $this->taskService->getTasks($filterTaskDto);
        $paginated_response = $this->taskResource->fromTaskstoArray($my_assigned_tasks, true);

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

    }

    public function get_rewards_by_id(Request $request, $productId){
        //Input Validations - start
        Log::info("V2ChildController::get_rewards_by_id()");
        $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('CHILD')
            ->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, $currentUser, true, $currentStore);
        }catch(Exception $e){
            return Helpers::responseMessage( $e->getCode(), $e->getMessage() );
        }

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

    public function createWish(Request $request){
        Log::info("V2ChildController::createWish()");
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'title' => 'required|string',
                'description' => 'string',
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $wish_arr = [];
        $wish_arr['title'] = $request->title;
        $wish_arr['description'] = $request->has('description') ? $request->description : null;
        $wish_arr['user_id'] = $currentUser->user_id;
        $wish_arr['group_id'] = $currentGroup->group_id;

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

        $wishObj = $this->wishlistService->createWish($wish_arr);
        $response_data = $this->wishlistResource->fromWishToArray($wishObj);
        return Helpers::successResponse(['data' => $response_data], 200, 'Data fetched successfully.');
    }

    public function get_app_wishlist(Request $request){
        Log::info("V2ChildController::get_app_wishlist()");
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $filter = WishlistFilterDTO::builder()
            ->user($currentUser)->store($currentStore)->group($currentGroup)
            ->build();
        $today = Carbon::now();
        $today_str = $today->format('Y-m-d');
        $savedProductFilter = FilterRewardDTO::builder()->copyFrom($filter)
            ->dueByGraterThan($today_str)
            ->loadWishListInfo(true)
            ->orderByColumn('created_at')
            ->order('ASC')
            ->build();

        $wishlist_objs = $this->wishlistService->getWishlistForUser($filter);
        $saved_products = $this->rewardService->getSavedProductsForUserAndGroup($savedProductFilter);
        $this->rewardService->loadAdditionalInfo($saved_products, $savedProductFilter);

        $response_data = [];
        $response_data['wishlist'] = $this->wishlistResource->fromWishesToArray($wishlist_objs);
        $response_data['saved_products'] = $this->rewardResource->fromRewardsToArray($saved_products, false, true, $currentUser, false, $currentStore, null);
        return Helpers::successResponse(['data' => $response_data], 200, 'Data fetched successfully.');
    }

    public function update_wish(Request $request, $wishId){
        Log::info("V2ChildController::update_wish()");
        $error_if_any = Helpers::validatorErrorResponse(
            $request, ['wish_id' => $wishId], [
                'wish_id' => 'required|numeric'
            ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);

        $filter = WishlistFilterDTO::builder()
            ->user($currentUser)->store($currentStore)->group($currentGroup)
            ->setWishIds([$wishId])
            ->build();

        $wishes = $this->wishlistService->getWishlistById($filter);
        $wish = null;
        if(count($wishes)>0){
            $wish = $wishes[0];
        } else {
            return Helpers::responseMessage( 404, 'Wish not found');
        }

        $wish_arr = [];
        $wish_arr['title'] = $request->has('title') ? $request->title : null;
        $wish_arr['description'] = $request->has('description') ? $request->description : null;
        $wish_arr['wish_img'] = $request->hasFile('wish_img') ?
            ( is_array($request->file('wish_img')) ? $request->file('wish_img')
                : [$request->file('wish_img')]) : null;

        $updated_wish = $this->wishlistService->updateWish($wish, $wish_arr);
        $response_data = $this->wishlistResource->fromWishToArray($updated_wish);
        return Helpers::successResponse(['data' => $response_data], 200, 'Data updated successfully.');

    }

    public function get_wish_by_id(Request $request, $wishId){
        Log::info("V2ChildController::get_wish_by_id()");

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

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

        $filter = WishlistFilterDTO::builder()
            ->user($currentUser)->store($currentStore)->group($currentGroup)
            ->setWishIds([$wishId])
            ->build();

        $wishes = $this->wishlistService->getWishlistById($filter);
        $wish = null;
        if(count($wishes)>0){
            $wish = $wishes[0];
        } else {
            return Helpers::responseMessage( 404, 'Wish not found');
        }
        $response_data = $this->wishlistResource->fromWishToArray($wish);
        return Helpers::successResponse(['data' => $response_data], 200, 'Data fetched successfully.');
    }

    public function create_new_claim_for_task(Request $request){
        Log::info("V2ChildController::create_new_claim_for_task()");
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'task_id' => 'required|numeric',
                'comments' => 'string'
        ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

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

            $getTaskDto = GetTaskDTO::builder()
                ->user($currentUser)->store($currentStore)->group($currentGroup)
                ->taskIds([$request->task_id])
                ->requiredFor('CHILD')
                ->getForGroupOrGlobal(true)
                ->build();
            $tasks = $this->taskService->getTasksById($getTaskDto);
            $task = null;

            if($tasks == null || count($tasks) == 0){
                return Helpers::responseMessage( 404, 'Task not found');
            }

            $task = $tasks[0];
            $isTaskVisible = $this->taskService->isTaskVisibleForChild($currentUser, $task);
            $taskAssigned = $this->taskService->getAssignedTask($currentUser, $currentStore,
                $currentGroup, $request->task_id);

            if($taskAssigned == null && $isTaskVisible){
                Log::debug("task is not assigned to user, but it is visible, so creating new assignment");
                $parentUser = $currentGroup->owner;
                $new_task_assignees_user_id_list = ['add' => [$currentUser->user_id]];
                $this->taskService->removeAndAddTaskAssignee($parentUser, $task, $new_task_assignees_user_id_list);
                $taskAssigned = $this->taskService->getAssignedTask($currentUser, $currentStore,
                    $currentGroup, $request->task_id);
            } else {
                Log::debug("task is not assigned to user, and it is not visible as well");
            }

            if($taskAssigned == null){
                return Helpers::responseMessage( 404, 'Task Assignment not found');
            }

            $claim_details = [];
            $claim_details['comments'] = $request->comments;
            $claim_details['approval_files'] = $request->hasFile('approval_files') ?
                ( is_array($request->file('approval_files')) ? $request->file('approval_files')
                    : [$request->file('approval_files')]) : null;


            $claim = $this->claimService->createNewClaimForTask($currentUser,
                $currentGroup, $currentStore, $taskAssigned, $claim_details);

            $response_data = $this->claimResource->fromClaimToArray($claim);
        }catch(Exception $e){
            Log::error($e->getTraceAsString());
            return Helpers::responseMessage( $e->getCode(), $e->getMessage());
        }

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

    public function create_new_claim_for_reward(Request $request){
        Log::info("V2ChildController::create_new_claim_for_reward()");
        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                'product_id' => 'required|numeric',
                // 'comments' => 'required|string'
        ]);
        if($error_if_any['flag'] != 0){
            return $error_if_any['response'];
        }

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

        try{
            $storeProduct = $this->rewardService->getStoreRewardById($currentUser, $currentStore,
                $currentGroup, $request->product_id);
            $isVisibleToChild = $this->rewardService->isRewardVisibleForChild($currentUser, $currentStore,
                $currentGroup, $request->product_id);

            if($storeProduct == null && $isVisibleToChild){
                Log::debug('reward is not assigned to user, but it is visible, so adding into the store');
                $this->rewardService->publishReward($currentUser, $currentGroup, $currentStore,
                    $request->product_id);
                $storeProduct = $this->rewardService->getStoreRewardById($currentUser, $currentStore,
                    $currentGroup, $request->product_id);
            }

            if($storeProduct == null){
                return Helpers::responseMessage( 404, 'Product not found in store');
            }

            $claim_details = [];
            $claim_details['comments'] = $request->has('comments') ? $request->comments : '';
            $claim_details['approval_files'] = $request->hasFile('approval_files') ?
            ( is_array($request->file('approval_files')) ? $request->file('approval_files')
                : [$request->file('approval_files')]) : null;

            $claim = $this->claimService->createNewClaimForProduct($currentUser,
                $currentGroup, $currentStore, $storeProduct, $claim_details);

            $response_data = $this->claimResource->fromClaimToArray($claim);
        }catch(Exception $e){
            return Helpers::responseMessage( $e->getCode(), $e->getMessage());
        }

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

    public function get_claims(Request $request){
        Log::info("V2ChildController::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;
        $goal_id = null;
        $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('CHILD')
            ->statusList($status_list)
            ->orderByColumn('created_at')
            ->order('DESC')
            ->page_no($page_no)
            ->limit($limit)
            ->build();

        $claims = $this->claimService->getClaimsForUser($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("V2ChildController::update_claim()");
        $error_if_any = Helpers::validatorErrorResponse(
            $request, ['claimId' => $claimId], [
                'claimId' => 'required|numeric',
                'new_status' => [ 'required', 'string', 'in:'. implode(",", ['PENDING']) ],
        ]);
        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('CHILD')
            ->claimIds([$claimId])
            ->orderByColumn('created_at')
            ->order('DESC')
            ->build();
        $claims = $this->claimService->getClaimsForUser($filterDto);
        if(count($claims) == 0){
            return Helpers::responseMessage( 404, 'Claim not found');
        }
        $claim = $claims[0];
        $claim = $this->claimService->changeClaimStatus($currentUser,
            $currentGroup, $currentStore, $claim, $request->new_status, false);

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

    public function list_rewards(Request $request) {
        Log::info("V2ChildController::list_rewards()");
        $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;
        // $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)
            ->orderByColumn('created_at')
            ->requiredFor('CHILD')
            // ->status('ACTIVE')
            ->dueByGraterThan(Carbon::now()->subDays(1)->format('Y-m-d'))
            ->order('DESC');


        // 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, $currentUser, false, $currentStore, null);

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

    public function getUserDashboardForApp(Request $request){
        Log::info("V2ChildController::getUserDashboardForApp()");
        $today = $request->has('today') && !empty($request->today)
        ? new Carbon($request->today) : Carbon::today();

        [$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']);

        $sp_wallet = $this->spWalletService->getSPWallet($currentUser);
        $sp_last_transactions = $this->spWalletService->getSPWalletLatestTransactions($currentUser, 1);
        $sp_last_transaction = !empty($sp_last_transactions) && count($sp_last_transactions) > 0 ? $sp_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, [$currentGroup->group_id], 10, 1);
        $activity_histories = $this->userActivityService->getLatestActivityHistory(
            $currentUser->user_id, [], 10, 1);
        $dynamic_banner_content = DynamicContent::
                            where('content_key', DynamicContent::KEY_CHILD_HOME_SCREEN_BANNER)
                            ->first();
        $dynamic_banner_on_click_link = DynamicContent::
                            where('content_key', DynamicContent::KEY_CHILD_HOME_SCREEN_BANNER_ON_CLICK_LINK)
                            ->first();
        $latest_activity_history = $this->commonService->getHasNewActivity($currentUser, $currentGroup, [$currentGroup->group_id]);
        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))->subDays(9)->startOfDay(),
            (new Carbon($today))->endOfDay(),
            [$currentUser->user_id]);

        $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_sp_wallet_transaction'] = $this->spWalletTransactionResource->fromSPWalletTransactionToArray($sp_last_transaction);
        $response_data['sp_balance_details'] = [
                'sp_balance' => Helpers::formatDecimanPointsSP($sp_wallet['balance']),
                'sp_balance_str' => Helpers::formatDecimanPointsSP($sp_wallet['balance']) ." SP",
                'sp_total_str' => Helpers::formatDecimanPointsSP($sp_wallet['total']) . " Lifetime"
            ];
        $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['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 getHasNewActivity(Request $request){
        Log::info("V2ChildController::getHasNewActivity()");
        [$currentUser, $currentStore, $currentGroup] = $this->getContextualDetails($request);
        $latest_activity_history = $this->commonService->getHasNewActivity($currentUser, $currentGroup, [$currentGroup->group_id]);
        return Helpers::successResponse(['data' => ['has_new_activity_history' => $latest_activity_history != null ? true : false]]
            , 200, 'Details retrieved successfully.');
    }

    public function get_children_attendance(Request $request){
        Log::info("V2ChildController::getUserDashboardForApp()");
        $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, [$currentUser->user_id]);
        return Helpers::successResponse(['data' => $response_json], 200, 'reward details retrieved successfully.');
    }

    public function update_children_attendance(Request $request){
        Log::info("V2ChildController::update_children_attendance()");

        $error_if_any = Helpers::validatorErrorResponse(
            $request, [], [
                '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);
        $user_id = $currentUser->user_id;
        $from_date = Carbon::createFromFormat('Y-m-d', $request->date)->startOfDay();
        $to_date = Carbon::createFromFormat('Y-m-d', $request->date)->endOfDay();

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

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

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

        if($existing_attendance != null){
            // return Helpers::responseMessage( 400, "can not change attendance, as it is already updated by Parent or Admin" );
            $response_json = [];
            $response_json['attendance_details'] = $this->getUserWiseCalendarAttendancesInGroup($currentGroup, $from_date, $to_date, [$user_id]);
            return Helpers::successResponse(['data' => $response_json], 200, 'can not change attendance, as it is already updated by Parent or Admin.');
        }

        $result = false;
        try{
            $result = $this->getAttendanceService()->updateAttendance($currentGroup, $user, $request->date, $request->present, 'CHILD', $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.." );
        }

        $response_json = [];

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

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

    private function getFilteredTasks($currentUser, $currentStore, $currentGroup, $request){
        Log::info("V2ChildController::getFilteredTasks()");
        $today = Carbon::now();
        $today_str = $today->format('Y-m-d');
        $filterTaskDto = FilterTaskDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->getForGroupOrGlobal(true)
            ->requiredFor('CHILD')
            ->page_no(1)
            ->limit(1)
            ->include_null_for_due_by(true)
            ->dueByGraterThan($today_str)
            ->build();

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

    private function getFilteredRewards($currentUser, $currentStore, $currentGroup, $request){
        Log::info("V2ChildController::getFilteredRewards()");
        $filterBuilder = FilterRewardDTO::builder()
            ->user($currentUser)
            ->store($currentStore)
            ->group($currentGroup)
            ->limit(1)
            ->page_no(1)
            ->orderByColumn('created_at')
            ->requiredFor('CHILD')
            // ->status('ACTIVE')
            ->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('CHILD')
            ->statusList($status_list)
            ->orderByColumn('created_at')
            ->order('DESC')
            ->page_no(1)
            ->limit(1)
            ->build();

        $claims = $this->claimService->getClaimsForUser($filterDto);
        return $claims;
    }
}
?>