RootZanli & NinjaCr3

: / home / o5t6x7pgljbm / public_html / app / Http / Controllers / Api /
Filename : RewardController.php
back
<?php

namespace App\Http\Controllers\Api;

use Illuminate\Http\Request;

use App\Http\Controllers\Controller;
use App\Models\Goal;
use App\Models\Group;
use App\Models\Product;
use App\Models\ProductCategory;
use App\Models\StoreProduct;
use App\Models\Store;
use App\Models\ProductClaimed;
use App\Models\ProductImage;
use App\Models\ProductWishlist;
use App\Models\User;
use Helpers;
use DB;
use Config;
use Faker\Extension\Helper;
use Image;
use Carbon\Carbon;

class RewardController extends Controller
{

    public function get_rewards(Request $request)
    {
        $user = $request->user();

        $res_data['data'] = Product::select('*')
                            ->where('product_type', 'REWARD')
                            ->where('group_id', $user->active_group_id)
                            ->where('status', 'ACTIVE')
                            ->get();

        return Helpers::successResponse($res_data, 200, 'Reward fetched successfully.');
    }

    public function get_rewards_catalog(Request $request)
    {
        /*$validated = $request->validate([
            'latitude' => 'required',
            'longitude' => 'required',
        ]);*/

        $user = $request->user();
   
        $data = $rewardArr = array();

        $activeStore = CommonController::getActiveStore($request);
        $rewards = Product::select('*', DB::raw("IF((SELECT count(*) FROM store_product WHERE store_id = '".$activeStore->store_id."' AND product_id = products.product_id),true,false) added_in_store"))
                                ->where('product_type', 'GLOBAL')
                          /*      ->where('status', 'ACTIVE')*/
                                ->orderBy('products.created_at')
                                ->limit(4)
                                ->get();

        foreach($rewards as $reward){
            $reward['added_in_store'] = $reward->added_in_store == 1 ? true : false;
            $rewardArr[] = $reward;
        }
        $data['rewards'] =  $rewardArr;                     
        if(isset($request->latitude) && isset($request->longitude)){
                $data['popular_product'] = Product::select('*', DB::raw("6371 * acos(cos(radians(" . $request->latitude . ")) 
                        * cos(radians(products.latitude)) 
                        * cos(radians(products.longitude) - radians(" . $request->longitude . ")) 
                        + sin(radians(" . $request->latitude . ")) 
                        * sin(radians(products.latitude))) AS distance"))
                               /* ->where('status', 'ACTIVE')*/
                                ->whereRaw("IF(product_type='REWARD', group_id='".$user->active_group_id."',1)")
                                ->orderByRaw('ISNULL(distance), distance ASC')
                                ->limit(30)
                                ->get();
        } else {
            $data['popular_product'] = Product::select('*')
                                ->whereRaw("IF(product_type='REWARD', group_id='".$user->active_group_id."',1)")
                               /* ->where('status', 'ACTIVE')*/
                                ->limit(30)
                                ->get();
        }
        $data['product_categories'] = ProductCategory::all(['product_category_id', 'product_category_name', 'product_category_image']);

        /*$data['quick_rewards'] = Product::select('*')
                                ->where('product_type', 'REWARD')
                                ->where('group_id', $user->active_group_id)
                                ->orderBy('products.created_at')
                                ->limit(4)
                                ->get();*/

        $res_data['data'] = $data;
        
        return Helpers::successResponse($res_data, 200, 'Goal fetched successfully.');
    }
    
    public function view_your_store(Request $request)
    {

        $user = $request->user();
   
        $data = $rewardArr = array();

        $activeStore = CommonController::getActiveStore($request);

        $rewards = StoreProduct::select('products.*', DB::raw('CONCAT("'.Config::get('constants.app.api-product-image-url').'",product_image) as product_image'))
                    ->leftJoin("store", "store.store_id", "=", "store_product.store_id")
                    ->leftJoin("products", "products.product_id", "=", "store_product.product_id")
                    ->where('product_type', 'GLOBAL')
                    ->where('store_product.store_id', $activeStore->store_id)
                    ->orderBy('products.created_at', 'desc')
                    ->get();             
        
        $res_data['data'] = $rewards;
        
        return Helpers::successResponse($res_data, 200, 'Store product fetched successfully.');
    }

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

        $user = $request->user();

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

        $store_id = $defaultStore->store_id;
        $storeProduct = StoreProduct::firstOrNew(['store_id' => $store_id, 'product_id' => $request->product_id]);

        if(!$storeProduct->exists){
            $storeProduct->store_id = $store_id;
            $storeProduct->product_id = $request->product_id;
            $storeProduct->save();

            return Helpers::responseMessage(200, 'Product add to store.');

        } else {

            $storeProduct->delete();
            return Helpers::responseMessage(200, 'Product remove from store.');
        }
    }

    public function create_reward(Request $request)
    {
        $validated = $request->validate([
            'product_name' => 'required',
            'description' => 'required',
            'product_img' => 'required',
            'product_sp' => 'required',
           /* 'expires_on' => 'required',*/
        ]);

        $user = $request->user();

        $request['expires_on'] = isset($request->expires_on) ? date('Y-m-d', strtotime($request->expires_on)) : null;
        $request['created_by'] = $user->user_id;
        $request['group_id'] = $user->active_group_id;

        $request['status'] = isset($request->status) ? $request->status : 'ACTIVE';

        $product = Product::create($request->all());

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

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

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

                // Save thumbnail image
                $img = Image::make($file->getRealPath());
                $img->resize(200, 200, function ($constraint) {
                    $constraint->aspectRatio();
                })->save(public_path('product_images/thumb/').$imageName);

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

                ProductImage::insert(['product_id' => $product->product_id, 'image_name' => $imageName]);

                if($key == 0)
                {
                    $product->product_image = $imageName;
                    $product->save();
                }
            }
        }
        
        return Helpers::responseMessage(200, 'Reward created successfully.');
    }

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

        $user = $request->user();

        Product::find($request->product_id)->delete();

        return Helpers::responseMessage(200, 'Reward deleted successfully.');
    }

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

        $user = $request->user();

        $storeProduct = StoreProduct::where('store_product_id', $request->store_product_id)->first();

        $product = Product::find($storeProduct->product_id);

        $productClaimedArr = ProductClaimed::where('store_product_id', $request->store_product_id)->get();

        foreach($productClaimedArr as $productClaimed){
            if(($request->status == 'APPROVED' || $request->status == 'REJECTED') && $productClaimed->status == 'PENDING_APPROVAL'){
                $productClaimed->status = $request->status;
            } else if($request->status == 'REWARDED' && $productClaimed->status == 'APPROVED'){
                $productClaimed->status = $request->status;
            }
            $productClaimed->save();

            /* Notification Code - Start */
            if($request->status == 'APPROVED'){
                $title = 'Reward Approved';
                $msg = $product->product_name.' reward has been approved.';
            } else if($request->status == 'REJECTED'){
                $title = 'Reward Rejected';
                $msg = $product->product_name.' reward has been rejected.';
            } else if($request->status == 'REWARDED'){
                $title = 'Reward Rewarded';
                $msg = $product->product_name.' reward has been rewarded.';
            }
            $type = 'product_claimed';
            $childUser = User::find($productClaimed->user_id);
            if($childUser->device_type == 'android'){
               Helpers::sendPushAndroid(array($childUser->device_token), $title, $msg, $type, $productClaimed->product_claimed_id); 
            } else if($childUser->device_type == 'ios'){
               Helpers::sendPushIOS(array($childUser->device_token), $title, $msg, $type, $productClaimed->product_claimed_id);
            }
            Helpers::storeNotifications($user->user_id, array($childUser->user_id), $title, $msg, $type, $productClaimed->product_claimed_id);
            /* Notification Code - End */

        }
        //ProductClaimed::where('store_product_id', $request->store_product_id)->update(['status' => $request->status]);

        return Helpers::responseMessage(200, 'Reward claim status has been changed.');
    }

    public function get_reward(Request $request){
        $validated = $request->validate([
            "product_id" => "required",
        ]);
 
        $user = $request->user();

        $product = Product::select("*", DB::raw("IF((SELECT count(*) FROM product_wishlist WHERE user_id = '".$user->user_id."' AND product_id = products.product_id),1,0) added_in_wishlist"))
                    ->where("product_id", $request->product_id)
                    ->first();
        //loading images in product
        $product->images;
        //enrich task details if product type is REWARD:
        if($product->product_type == 'REWARD'){
            $activeStore = CommonController::getActiveStore($request);
            if(isset($activeStore)){
                $product['task'] = TaskController::getTaskForProduct($request->user(), $activeStore, $product, true);
            } else {
                return Helpers::responseMessage(400, "Default Group not selected, please switch your active group");
            }
        }
        $product['added_in_wishlist'] = ($product->added_in_wishlist == 1) ? true : false;
        if(isset($product) && $product->product_id > 0){
            return Helpers::successResponse(array('data'=> $product), 200, 'Reward fetched successfully.');
        } else {
            return Helpers::responseMessage(404, "Reward not found with given product_id");
        }
    }

    /**
     * Edit product
     * Fields:
     *      product_id: required field
     *      product_type: //can not be changed
     *      group_id: //can be updated only if it's null set in db
     *      product_category_id: // can be updated on if it's null set in db
     *      product_name:
     *      description:
     *      product_img: check how to expect this. it would be file field.
     *      product_sp: numeric only
     *      expires_on: in Y-m-d format only
     *      is_featured:
     *      latitude:
     *      longitude:
     */
    public function edit_reward(Request $request){
        $validated = $request->validate([
            "product_id" => "required",
          /*  "group_id" => "numeric",
            "product_category_id" => "numeric",
            "is_featured" => "boolean",
            "expires_on" => "date_format:Y-m-d",*/
        ]);

        $product = Product::select("*")
                    ->where("product_id", $request->product_id)
                    ->first();
        if(!isset($product) || $product->product_id <= 0){
            return Helpers::responseMessage(404, "Reward not found with given product_id");
        }

        //edit flow - start
        //setting  group_id and product_category_id only if in db it's not set or it's null.
        if(isset($request->group_id) &&
            (!isset($product->group_id) || $product->group_id == null ) ){
                $product->group_id = $request->group_id;
        }
        if(isset($request->product_category_id) &&
            (!isset($product->product_category_id) || $product->product_category_id == null ) ){
                $product->product_category_id = $request->product_category_id;
        }

        if(isset($request->product_name))
            $product->product_name = $request->product_name;
        if(isset($request->description))
            $product->description=$request->description;
        if(isset($request->product_sp))
            $product->product_sp = $request->product_sp;
        if(isset($request->is_featured))
            $product->is_featured = $request->is_featured=="1" || trim($request->is_feature)=="true" ? true : false;
        if(isset($request->expires_on))
            $product->expires_on = date("Y-m-d", strtotime($request->expires_on));
        if(isset($request->latitude))
            $product->latitude = $request->latitude;
        if(isset($request->longitude))
            $product->longitude = $request->longitude;
        if(isset($request->status))
            $product->status = $request->status;

        if(isset($request->product_img) && $request->hasFile('product_img'))
        {
            //Deleting all previous images to save newly sent images
            ProductImage::where("product_id", $product->product_id)
                        ->delete();
            $imageFiles = array();
            if(is_array($request->product_img))
                $imageFiles = $request->file('product_img');
            else{
                $imageFiles[] = $request->file('product_img');
            }
            foreach($imageFiles AS $key => $file){
                $imageName = $this->saveProductImage($product, $file);
                if($key == 0)
                    $product->product_image = $imageName;
            }
        }
        $result = $product->save();
        if($result){
            return Helpers::responseMessage(200, 'Reward saved successfully.');
        } else {
            return Helpers::responseMessage(500, 'Reward could not be edited');
        }
        //edit flow -end
    }

    private function saveProductImage($product, $file){
        $imageName = rand().time().'.'.$file->getClientOriginalExtension();

        // Save thumbnail image
        $img = Image::make($file->getRealPath());
        $img->resize(200, 200, function ($constraint) {
            $constraint->aspectRatio();
        })->save(public_path('product_images/thumb/').$imageName);

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

        ProductImage::insert(['product_id' => $product->product_id, 'image_name' => $imageName]);
        return $imageName;
    }

    public function addOrRemoveProductToWishlist(Request $request){
        $validated = $request->validate([
            "product_id" => "required|numeric",
            "operation" => "in:ADD,REMOVE,TOGGLE"
        ]);
        $operation = $request->has('operation') ? $request->operation : 'TOGGLE';
        $user = $request->user();
        $productWishlistObj = ProductWishlist::where('product_id', $request->product_id)
                        ->where('user_id', $user->user_id)->first();
        $success = false;
        switch($operation){
            case 'ADD':
                if(isset($productWishlistObj) )
                   return Helpers::responseMessage(400, 'Product already in wishlist');
                else{
                    $productWishlistObj = ProductWishlist::create([
                        'user_id' => $user->user_id,
                        'product_id' => $request->product_id
                    ]);
                    $success = $productWishlistObj->save();
                }
                break;
            case 'REMOVE':
                if(isset($productWishlistObj))
                    $success = $productWishlistObj->delete();
                else
                    return Helpers::responseMessage(400, 'Product not present in wishlist');
                break;
            case 'TOGGLE':
                if(isset($productWishlistObj))
                    $sucess = $productWishlistObj->delete();
                else{
                    $productWishlistObj = ProductWishlist::create([
                        'user_id' => $user->user_id,
                        'product_id' => $request->product_id
                    ]);
                    $success = $productWishlistObj->save();
                }
                break;
        }
        if($success)
            return Helpers::responseMessage(200, 'wishlist is updated');
        else
            return Helpers::responseMessage(500, 'wishlist update failed');
    }


    /* Dev Gautam - start */
    function get_claimes_by_status ($status,$group_id,$use_paginate){
        // $limit = 1;
        // if($status === "APPROVED" || $status === "REWARDED") $limit = 2;
        $query = ProductClaimed::select("tasks.task_title", 
                                DB::raw('CONCAT("'.Config::get('constants.app.api-product-image-url').'",product_image) as product_image'),
                                "products.description","products.product_sp", "product_claimed.status", "products.product_name",
                                "product_claimed.store_product_id","product_claimed.product_claimed_id", "products.product_id")
                                ->leftJoin("store_product", "store_product.store_product_id", "=", "product_claimed.store_product_id")
                                ->leftJoin("store", "store.store_id", "=", "store_product.store_id")
                                ->leftJoin("products", "products.product_id", "=", "store_product.product_id")
                                ->leftJoin("tasks", "tasks.product_id", "=", "store_product.product_id")
                                ->where("store.group_id", $group_id)
                                ->where("products.status", 'ACTIVE')
                                ->where("product_claimed.status",$status)
                                ->orderBy('product_claimed.created_at','desc');
            
        return $use_paginate ? $query->paginate(5) : $query->limit(2)->get();
    }
    function get_claimed_by_images ($store_product_id){
        return ProductClaimed::select('users.full_name', 'users.email', 'users.mobile',
                                DB::raw('CONCAT("'.Config::get('constants.app.api-profile-pic-url').'",profile_pic) as profile_pic'))
                                ->leftJoin('users', 'users.user_id', 'product_claimed.user_id')
                                ->where('store_product_id', $store_product_id)
                                ->limit(2)
                                ->get();
    }
    function get_claims_count($group_id,$status){
        return ProductClaimed::select(DB::raw('count(product_claimed.status) as claims_count'))
                            ->leftJoin("store_product", "store_product.store_product_id", "=", "product_claimed.store_product_id")
                            ->leftJoin("store", "store.store_id", "=", "store_product.store_id")
                            ->where("store.group_id", $group_id)
                            ->where("product_claimed.status",$status)
                            ->first();
    }

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

        $group_id     = $request->user()->active_group_id;
        $status       = $request->status;
        $use_paginate = true;

        if($status === "PENDING_APPROVAL"){
            $pending_approval_status = $this->get_claimes_by_status("PENDING_APPROVAL",$group_id,$use_paginate);
            $items                   = $pending_approval_status->getCollection();
            if(count($items) > 0){
                foreach($items as $key => $item){
                    $items[$key]['claimed_by'] = $this->get_claimed_by_images($item->store_product_id);
                }
                $claims = $pending_approval_status->setCollection($items);
                $count  = $this->get_claims_count($group_id,"PENDING_APPROVAL");
                $data['data']['claim_cnt'] = $count->claims_count;
                $data['data']['claims']    = $claims;
            }
            else{
                $claims = $pending_approval_status->setCollection($items);
                $data['data']['claim_cnt'] = 0;
                $data['data']['claims'] = $claims;
            }
        }
        // return $data;
        else if($status === "APPROVED"){
            $approved_status         = $this->get_claimes_by_status("APPROVED",$group_id,$use_paginate);
            $items                   = $approved_status->getCollection();
            if(count($items) > 0){
                foreach($items as $key => $item){
                    $items[$key]['claimed_by'] = $this->get_claimed_by_images($item->store_product_id);
                }
                $claims = $approved_status->setCollection($items);
                $count  = $this->get_claims_count($group_id,"APPROVED");
                $data['data']['claim_cnt'] = $count->claims_count;
                $data['data']['claims']    = $claims;
            }
            else{
                $claims = $approved_status->setCollection($items);
                $data['data']['claim_cnt'] = 0;
                $data['data']['claims'] = $claims;
            }
        }
        else if($status === "REWARDED"){
            $rewarded_status         = $this->get_claimes_by_status("REWARDED",$group_id,$use_paginate);
            $items                   = $rewarded_status->getCollection();
            if(count($items) > 0){
                foreach($items as $key => $item){
                    $items[$key]['claimed_by'] = $this->get_claimed_by_images($item->store_product_id);
                }
                $claims = $rewarded_status->setCollection($items);
                $count  = $this->get_claims_count($group_id,"REWARDED");
                $data['data']['claim_cnt'] = $count->claims_count;
                $data['data']['claims']    = $claims;
            }
            else{
                $claims = $rewarded_status->setCollection($items);
                $data['data']['claim_cnt'] = 0;
                $data['data']['claims'] = $claims;
            }
        }
        return Helpers::successResponse($data, 200, 'Claims fetched successfully.');
    }
    
    function get_claims(Request $request){
        $group_id = $request->user()->active_group_id;
        // $status = $request->status;
        $use_paginate = false;
        // $pending_approval_status = $approved_status = $rewarded_status = [];

        $pending_approval_status = $this->get_claimes_by_status("PENDING_APPROVAL",$group_id,$use_paginate);
        $approved_status         = $this->get_claimes_by_status("APPROVED",$group_id,$use_paginate);
        $rewarded_status         = $this->get_claimes_by_status("REWARDED",$group_id,$use_paginate);

        $claims = [];
        if(count($pending_approval_status) > 0){
            $count = $this->get_claims_count($group_id,"PENDING_APPROVAL");
            $claims['pending_approval_counts'] = $count->claims_count;
            foreach($pending_approval_status as $item){
                $claim                             = $item;
                $claim['claimed_by']               = $this->get_claimed_by_images($item->store_product_id);
                $claims['pending_approval_claims'][] = $claim;
            }
            $data['data'] = $claims;
        }else{
            $claims['pending_approval_counts'] = 0;
            $claims['pending_approval_claims'] = [];
        }
        
        if(count($approved_status) > 0){
            $count = $this->get_claims_count($group_id,"APPROVED");
            $claims['approved_counts']    = $count->claims_count;
            foreach($approved_status as $item){
                $claim                       = $item;
                $claim['claimed_by']         = $this->get_claimed_by_images($item->store_product_id);
                $claims['approved_claims'][] = $claim;
            }
            $data['data'] = $claims;
        }else{
            $claims['approved_counts'] = 0;
            $claims['approved_claims'] = [];
        }
        // $data['data'] = $claims;
        if(count($rewarded_status) > 0){
            $count = $this->get_claims_count($group_id,"REWARDED");
            $claims['reward_count']    = $count->claims_count;
            foreach($rewarded_status as $item){
                $claim                     = $item;
                $claim['claimed_by']       = $this->get_claimed_by_images($item->store_product_id);
                $claims['reward_claims'][] = $claim;
            }
            $data['data'] = $claims;
        }else{
            $claims['reward_count'] = 0;
            $claims['reward_claims'] = [];
            $data['data'] = $claims;
        }
        
        return Helpers::successResponse($data, 200, 'Claims fetched successfully.');
    }

    function view_all_claims_of_child(Request $request){

        $start_of_week = Carbon::now()->startOfWeek()->format('Y-m-d 00:00:00');
        $end_of_week   = Carbon::now()->endOfWeek()->format('Y-m-d 23:59:59');

        $group_id     = $request->user()->active_group_id;
        $user_id      = $request->user()->user_id;

        $query = ProductClaimed::select("tasks.task_title", "tasks.task_id",
                                DB::raw('CONCAT("'.Config::get('constants.app.api-product-image-url').'",product_image) as product_image'), 'products.product_id',
                                "products.description", "product_claimed.status", "products.product_name", "products.product_sp","product_claimed.created_at")
                                ->leftJoin("store_product", "store_product.store_product_id", "=", "product_claimed.store_product_id")
                                ->leftJoin("store", "store.store_id", "=", "store_product.store_id")
                                ->leftJoin("products", "products.product_id", "=", "store_product.product_id")
                                ->leftJoin("tasks", "tasks.product_id", "=", "store_product.product_id")
                                ->where("store.group_id", $group_id)
                                ->where("products.status", 'ACTIVE')
                                ->whereNull("products.deleted_at")
                                ->where("product_claimed.user_id",$user_id);

        if($request->flag === 'claimed_this_week'){
            $query->whereBetween('product_claimed.created_at', [$start_of_week, $end_of_week]);
        } 
        if(!empty($request->goal_id)){
            $data['data']['goal'] = Goal::where('goal_id', $request->goal_id)->first();
            $query->where("tasks.goal_id", $request->goal_id);
        }
        if(!empty($request->status)){
            $query->where('product_claimed.status', $request->status);
        }
        $claims = $query->orderBy('created_at','desc')
                  ->paginate(5);

        $data['data']['claim_counts'] = $claims->total();
        $data['data']['claims'] = $claims;

        return Helpers::successResponse($data, 200, 'Claims fetched successfully.');
    }

    function get_claims_child(Request $request){

        $start_of_week = Carbon::now()->startOfWeek()->format('Y-m-d 00:00:00');
        $end_of_week   = Carbon::now()->endOfWeek()->format('Y-m-d 23:59:59');

        $group_id     = $request->user()->active_group_id;
        $user_id      = $request->user()->user_id;
        
        $query = ProductClaimed::select("tasks.task_title", "tasks.task_id",
                                DB::raw('CONCAT("'.Config::get('constants.app.api-product-image-url').'",product_image) as product_image'), 'products.product_id',
                                "products.description", "product_claimed.status", "products.product_name", "products.product_sp", 'product_claimed.product_claimed_id',
                                'product_claimed.created_at')
                                ->leftJoin("store_product", "store_product.store_product_id", "=", "product_claimed.store_product_id")
                                ->leftJoin("store", "store.store_id", "=", "store_product.store_id")
                                ->leftJoin("products", "products.product_id", "=", "store_product.product_id")
                                ->leftJoin("tasks", "tasks.product_id", "=", "store_product.product_id")
                                ->where("store.group_id", $group_id)
                                ->whereNull("products.deleted_at")
                                ->where("products.status", 'ACTIVE')
                                ->where("product_claimed.user_id",$user_id);

        $claims = [];
        
        if($request->status === "PENDING_APPROVAL"){
            $claims['recent'] = "Recent pending approval";
            $items = $query->where('product_claimed.status',$request->status)
                    ->limit(3)
                    ->orderBy('product_claimed.created_at','desc')
                    ->get();
        }
        else if($request->status === "REWARDED"){
            $claims['recent'] = "Recent rewards";
            $items = $query->where('product_claimed.status',$request->status)
                    ->limit(3)
                    ->orderBy('product_claimed.created_at','desc')
                    ->get();
        }
        else {
            $claims['recent'] = "claimed this week";
            $items = $query->whereBetween('product_claimed.created_at', [$start_of_week, $end_of_week])
                    ->limit(2)
                    ->orderBy('product_claimed.created_at','desc')
                    ->get();
        }
        
        if(count($items) > 0){
            foreach($items as $item){
                $claims['claims'][] = $item;
            }
            $data['data'] = $claims;
        }
        else $claims['claims'] = [];
        
        $goals = Goal::all();
       
        if(count($goals) > 0){
            foreach($goals as $goal){
                $categoryTask = $goal;
                $query = ProductClaimed::select("tasks.task_title", "tasks.task_id",
                                        DB::raw('CONCAT("'.Config::get('constants.app.api-product-image-url').'",product_image) as product_image'), 'products.product_id',
                                        "products.description", "product_claimed.status", "products.product_name", "products.product_sp")
                                        ->leftJoin("store_product", "store_product.store_product_id", "=", "product_claimed.store_product_id")
                                        ->leftJoin("store", "store.store_id", "=", "store_product.store_id")
                                        ->leftJoin("products", "products.product_id", "=", "store_product.product_id")
                                        ->leftJoin("tasks", "tasks.product_id", "=", "store_product.product_id")
                                        ->where("tasks.goal_id", $goal->goal_id)
                                        ->where("product_claimed.user_id",$user_id)
                                        ->where("products.status", 'ACTIVE')
                                        ->where("store.group_id", $group_id);

                if($request->status === "PENDING_APPROVAL"){
                    $categoryTask['tasks'] = $query->where("product_claimed.status",$request->status)
                                            ->orderBy('product_claimed.created_at','desc')
                                            ->limit(3)
                                            ->get();
                }
                else if($request->status === "REWARDED"){
                    $categoryTask['tasks'] = $query->where("product_claimed.status",$request->status)
                                             ->orderBy('product_claimed.created_at','desc')
                                            ->limit(3)
                                            ->get();
                }
                else {
                    $categoryTask['tasks'] = $query->limit(3)->get();
                }
                $claims['tasks'][] = $categoryTask;
            }
        }
        else{
            $categoryTask['tasks'] = [];
            $claims['tasks'][] = $categoryTask;
        }
        $data['data'] = $claims;
        return Helpers::successResponse($data, 200, 'Rewards fetched successfully.');
    }

    /* Dev Gautam - end */

}