mivita/app/Cron/BusinessUsersStore.php

<?php
namespace App\Cron;

use App\User;
use stdClass;
use App\Models\UserBusinessStructure;
use App\Services\BusinessPlan\TreeCalcBot;

class BusinessUsersStore
{
    private $month;
    private $year;

    private $user_business_structure;
    private $users_structure = [];

 
    public function __construct($month, $year)
    {
        $this->month = $month;
        $this->year = $year;
    }


    public function getStoreUserBusinessStructure(){
        return UserBusinessStructure::where('year', $this->year)->where('month', $this->month)->first();
    }

    public function storeUserBusinessStructure()
    {
        if($this->user_business_structure = $this->getStoreUserBusinessStructure()){
            return $this->user_business_structure;
        }
        $treeCalcBot = new TreeCalcBot($this->month, $this->year, 'admin');
        //only load, when no structur is save
        $treeCalcBot->initStructureAdmin(false);
        $this->storeStructure($treeCalcBot);
    }

    public function storeBusinessUsersDetail()
    {
        if(!$this->user_business_structure){
            $this->user_business_structure = $this->getStoreUserBusinessStructure();
            if(!$this->user_business_structure){
                abort(403, 'not found UserBusinessStructure');
            }
        }
        foreach($this->user_business_structure->users as $user_id=>$completed){
            if($completed === 0){
                $user = User::find($user_id);        
                if($user){
                    $TreeCalcBot = new TreeCalcBot($this->month, $this->year, 'admin');
                    $TreeCalcBot->initBusinesslUserDetail($user);
                    if(!$TreeCalcBot->business_user){
                        abort(403, 'not found TreeCalcBot->business_user');
                    }
                    $this->storeBusinesslUser($TreeCalcBot->business_user);
                    $users = $this->user_business_structure->users;
                    $users[$user_id] = 1;
                    $this->user_business_structure->users = $users;
                    $this->user_business_structure->save();
                }
               
            }
        }
    }


    public function storeBusinesslUser($business_user){
        $b_user = $business_user->getBUser();
        $b_user->user_items = $this->storeUserItems($business_user->businessUserItems, 1);
        $b_user->b_structure_id = $this->user_business_structure->id;
        $b_user->save();
    }


    public function storeBusinessCompleted(){
        if(!$this->user_business_structure){
            $this->user_business_structure = $this->getStoreUserBusinessStructure();
        }
         foreach($this->user_business_structure->users as $user_id=>$completed){
            if($completed === 0){
                return false;
            }
            $this->user_business_structure->completed = 1;
            $this->user_business_structure->save();
        }
        return true;
    }
    

    private function storeUserItems($userItems, $line){
        $ret = [];
        foreach($userItems as $userItem){
            $temp = null;
            if(count($userItem->businessUserItems) > 0){
                $temp = $this->storeUserItems($userItem->businessUserItems, $line+1);
            }
            $obj = new stdClass();
            $obj->user_id = $userItem->user_id;
            $obj->line = $line;
            $obj->points = $userItem->sales_volume_points_sum;
            $obj->parents = $temp;
            $ret[] = $obj;        
        }
        return $ret;
    }


    private function storeStructure($treeCalcBot)
    {
        /*if($this->user_business_structure = $this->getStoreUserBusinessStructure()){
            return $this->user_business_structure;
        }*/

        $structure = [];
        foreach($treeCalcBot->business_users as $business_user){
            $structure[] = $this->storeStructureItem($business_user, 0);
        }

        $parentless = [];
        if($treeCalcBot->parentless){
            foreach($treeCalcBot->parentless as $pless){
                $parentless[] = $this->storeStructureItem($pless, 0);
            }
        }
        $fill = [
            'month' =>  $this->month,
            'year' =>  $this->year,
            'structure' => $structure,
            'parentless' => $parentless,
            'users' => $this->users_structure,
            'completed' => false,
            'status' => 0
        ];
        $this->user_business_structure = UserBusinessStructure::create($fill);
        return $this->user_business_structure;
    }

   

    private function storeStructureItem($item, $deep){
        $temp = null;
        if($item->businessUserItems){
            foreach($item->businessUserItems as $parent){
                $temp[] = $this->storeStructureItem($parent, $deep+1);
            }        
        }
        $this->users_structure[$item->user_id] = 0;
        $obj = new stdClass();
        $obj->user_id = $item->user_id;
        //$obj->name = $item->first_name .' '. $item->last_name ;
        $obj->email = $item->email;
        $obj->deep = $deep;
        //$obj->points = $item->sales_volume_points_sum;
        $obj->parents = $temp;
        return $obj;
    }

   

}