Proyectos de Subversion LeadersLinked - Backend

<?php
declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\Log\LoggerInterface;
use Laminas\View\Model\ViewModel;
use Laminas\View\Model\JsonModel;
use LeadersLinked\Library\Functions;
use LeadersLinked\Mapper\UserMapper;

use LeadersLinked\Model\User;
use LeadersLinked\Mapper\QueryMapper;
use LeadersLinked\Mapper\HabitUserMapper;
use LeadersLinked\Mapper\HabitUserLogCategoryMapper;
use LeadersLinked\Mapper\HabitCategoryMapper;
use LeadersLinked\Model\HabitUserLogContent;
use LeadersLinked\Mapper\HabitUserLogContentMapper;
use LeadersLinked\Mapper\HabitContentMapper;



class HabitProgressController extends AbstractActionController
{
    /**
     *
     * @var \Laminas\Db\Adapter\AdapterInterface
     */
    private $adapter;
    
    /**
     *
     * @var \LeadersLinked\Cache\CacheInterface
     */
    private $cache;
    
    
    /**
     *
     * @var \Laminas\Log\LoggerInterface
     */
    private $logger;
    
    /**
     *
     * @var array
     */
    private $config;
    
    
    /**
     *
     * @var \Laminas\Mvc\I18n\Translator
     */
    private $translator;
    
    
    /**
     *
     * @param \Laminas\Db\Adapter\AdapterInterface $adapter
     * @param \LeadersLinked\Cache\CacheInterface $cache
     * @param \Laminas\Log\LoggerInterface LoggerInterface $logger
     * @param array $config
     * @param \Laminas\Mvc\I18n\Translator $translator
     */
    public function __construct($adapter, $cache, $logger, $config, $translator)
    {
        $this->adapter      = $adapter;
        $this->cache        = $cache;
        $this->logger       = $logger;
        $this->config       = $config;
        $this->translator   = $translator;
    }
    
    public function indexAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request = $this->getRequest();
        
        if($request->isGet())
        {
            $categories = [];
            $habitCategoryMapper = HabitCategoryMapper::getInstance($this->adapter);
            $records = $habitCategoryMapper->fetchAllActiveByCompanyId($currentCompany->id);
            
            foreach($records as $record) 
            {
                $categories[ $record->id ] = $record->name;    
            }
            
            
            $headers  = $request->getHeaders();
            
            $isJson = false;
            if($headers->has('Accept')) {
                $accept = $headers->get('Accept');
                
                $prioritized = $accept->getPrioritized();
                
                foreach($prioritized as $key => $value) {
                    $raw = trim($value->getRaw());
                    
                    if(!$isJson) {
                        $isJson = strpos($raw, 'json');
                    }
                    
                }
            }
            
            if($isJson) {
                
                $id = Functions::sanitizeFilterString($this->params()->fromQuery('id'));
                if(!$id) {
                    return new JsonModel([
                       'success' => true, 
                        'data' => [
                           'items' => [],
                           'total' => 0, 
                        ]
                    ]);
                }
                
                
                
                $userMapper = UserMapper::getInstance($this->adapter);
                $user = $userMapper->fetchOneByUuidAndNetworkId($id, $currentCompany->network_id);
                
                if(!$user) {
                    return new JsonModel([
                        'success' => falsee,
                        'data' => 'ERROR_USER_NOT_FOUND'
                    ]);
                }
                
                $habitUserMapper = HabitUserMapper::getInstance($this->adapter);
                $habitUser = $habitUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
                
                
                if(!$habitUser) {
                    return new JsonModel([
                        'success' => falsee,
                        'data' => 'ERROR_HABITS_USER_NOT_FOUND'
                    ]);
                }
                
                $search = $this->params()->fromQuery('search', []);
                $search = empty($search['value']) ? '' :  Functions::sanitizeFilterString($search['value']);
                
                $page               = intval($this->params()->fromQuery('start', 1), 10);
                $records_x_page     = intval($this->params()->fromQuery('length', 10), 10);
                $order =  $this->params()->fromQuery('order', []);
                $order_field        = empty($order[0]['column']) ? 99 :  intval($order[0]['column'], 10);
                $order_direction    = empty($order[0]['dir']) ? 'ASC' : strtoupper(Functions::sanitizeFilterString($order[0]['dir']));
                
                
                
                
                $fields =  ['date'];
                $order_field = isset($fields[$order_field]) ? $fields[$order_field] : 'date';
                
                if(!in_array($order_direction, ['ASC', 'DESC'])) {
                    $order_direction = 'ASC';
                }
                
                $items = [];
                
                $habitContentMapper = HabitContentMapper::getInstance($this->adapter);
                $records = $habitContentMapper->fetchAllByCompanyId($currentCompany->id);
                
                $contents = [];
                foreach($records as $record)
                {
                    $contents[ $record->id ] = $record->file;
                }
          
                $habitUserLogContentMapper = HabitUserLogContentMapper::getInstance($this->adapter);
                $habitUserLogCategoryMapper = HabitUserLogCategoryMapper::getInstance($this->adapter);
                $paginator = $habitUserLogCategoryMapper->fetchOnlyDateDataTableByUserId($habitUser->id, $search, $page, $records_x_page, $order_field, $order_direction);
               
              
                
                $records = $paginator->getCurrentItems();
                
                
                
                
           
                
                foreach($records as $record)
                {

                    $date = $record['date'];
                    
                    $item = [
                        'date' =>  $date,
                    ];
                    
                    foreach($categories as $category_id => $category_name)
                    {
                    
                        $habitCategory = $habitUserLogCategoryMapper->fetchOneByUserIdAndCategoryIdAndDate($user->id, $category_id, $date);
                        if($habitCategory) {
                            $item['cat_' . $category_id] = $habitCategory->code;
                        } else {
                            $item['cat_' . $category_id] = '';
                        }
                        
                      
                        
                       
                        
                    }
                    
                    $habitUserLogContent = $habitUserLogContentMapper->fetchOneByUserIdAndDate($user->id, $date);
                    if($habitUserLogContent) {
                        $item['content'] = $contents[ $habitUserLogContent->content_id ] ;
                    } else {
                        $item['content'] = '';
                    }
                    
                    array_push($items, $item);
                    
                    
                }
                
               
                
                
                
                return new JsonModel([
                    'success' => true,
                    'data' => [
                        'items' => $items, 
                        'total' => $paginator->getTotalItemCount()
                    ]
                ]);
            } else {
                $queryMapper = QueryMapper::getInstance($this->adapter);
                $select = $queryMapper->getSql()->select();
                $select->columns([]);
                $select->from(['cu' => HabitUserMapper::_TABLE]);
                $select->join(['u' => UserMapper::_TABLE], 'cu.user_id = u.id',  ['uuid', 'first_name', 'last_name', 'email']);
                
                
                $select->where->equalTo('cu.company_id', $currentCompany->id);
    
                
                $select->order('first_name, last_name, email');
                
                $users = [];
                $records = $queryMapper->fetchAll($select);
                foreach($records as $record)
                {
                    $users[ $record['uuid'] ] = trim($record['first_name'] . ' ' . $record['last_name']) . ' (' . $record['email'] . ')'; 
                
                }
                
                
                
                $this->layout()->setTemplate('layout/layout-backend');
                $viewModel = new ViewModel();
                $viewModel->setTemplate('leaders-linked/habits/progress.phtml');
                $viewModel->setVariables([
                    'users' => $users,
                    'categories' => $categories,
                ]);
                
                return $viewModel ;
            }
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);;
        }
    }
    
    
    
   
   
    
   
    
}