Proyectos de Subversion LeadersLinked - Antes de SPA

<?php

declare(strict_types=1);

namespace LeadersLinked\Mapper;

use Laminas\Db\Adapter\AdapterInterface;
use Laminas\Db\Sql\Expression;
Use LeadersLinked\Hydrator\ObjectPropertyHydrator;
use LeadersLinked\Mapper\Common\MapperCommon;
use LeadersLinked\Model\Connection;

class ConnectionMapper extends MapperCommon
{
    const _TABLE = 'tbl_connections';

    
    /**
     *
     * @var ConnectionMapper
     */
    private static $_instance;
    
    /**
     *
     * @param AdapterInterface $adapter
     */
    private function __construct($adapter)
    {
        parent::__construct($adapter);
    }
    
    /**
     *
     * @param AdapterInterface $adapter
     * @return ConnectionMapper
     */
    public static function getInstance($adapter)
    {
        if(self::$_instance == null) {
            self::$_instance = new ConnectionMapper($adapter);
        }
        return self::$_instance;
    }

  
    /*
    public function fetchAllConnectionByUserIdReturnIds(int $user_id, $return_full_array = false, int $currentpage = 1, int $limit = 10, string $status = Connection::STATUS_ACCEPTED) 
    {
        $connections_array = [];
     
        $select = $this->sql->select();
        $select->columns(['request_from', 'request_to']);
        $select->from(self::_TABLE);
        $select->where->equalTo('status',  $status);
        $select->where->and->nest()
            ->equalTo('request_from', $user_id)
            ->or->equalTo('request_to', $user_id)
            ->unnest();
        
           
        
        $connections = $this->executeFetchAllArray($select);
        if ($connections) {
            for ($i = 0, $max = count($connections); $i < $max; $i++) 
            {
                $request_from = $connections[$i]['request_from'];
                $request_to = $connections[$i]['request_to'];
                if ($request_from == $user_id) {
                    array_push($connections_array, $request_to);
                } else {
                    array_push($connections_array, $request_from);
                }
            }
        }
        if ($return_full_array) {
            $offset = ( $currentpage - 1 ) * $limit;
            $connections_array = array_slice($connections_array, $offset, $limit);
        }
        return $connections_array;
    }

    function fetchAllConnectionByUserIdsReturnIds(array $userIds, int $user_id, $return_full_array = false, int $currentpage = 1, int $limit = 10, string $status = Connection::STATUS_ACCEPTED) 
    {
        $select = $this->sql->select();
        $select->columns(['request_from', 'request_to']);
        $select->from(self::_TABLE);
        $select->where->equalTo('status',  $status);
        $select->where->and->nest()
            ->nest()
            ->equalTo('request_from', $user_id)
            ->and->in('request_to', $userIds)
            ->unnest()
            ->or->nest()
            ->equalTo('request_to', $user_id)
            ->and->in('request_from', $userIds)
            ->unnest()
       ->unnest();     
        
       $connections_array = [];
       $connections = $this->executeFetchAllArray($select);
       if ($connections) {
           for ($i = 0, $max = count($connections); $i < $max; $i++)
           {
               $request_from = $connections[$i]['request_from'];
               $request_to = $connections[$i]['request_to'];
               if ($request_from == $user_id) {
                   array_push($connections_array, $request_to);
               } else {
                   array_push($connections_array, $request_from);
               }
           }
       }
       if ($return_full_array) {
           $offset = ( $currentpage - 1 ) * $limit;
           $connections_array = array_slice($connections_array, $offset, $limit);
       }
       return $connections_array;
    }
    

    public function fetchAllPendingInvitationsByIdUser(int $user_id, bool $return_full_array = false, int $currentpage = 1, int $limit = 10, string $status = Connection::STATUS_ACCEPTED)
    {
       
        $select = $this->sql->select(self::_TABLE);
        $select->columns(['request_from']);
        $select->where->equalTo('request_to', $user_id)->and->equalTo('status',  $status);
        
        $invitations_array = []; 
        $invitations = $this->executeFetchAllArray($select);
        if ($invitations) {
            for ($i = 0 , $max = count($invitations) ; $i < $max ; $i++) 
            {
                $request_from = $invitations[$i]['request_from'];
                array_push($invitations_array, $request_from);
            }
        }
        if ($return_full_array) {
            $offset = ( $currentpage - 1 ) * $limit;
            $invitations_array = array_slice($invitations_array, $offset, $limit);
        }
        return $invitations_array;
    }
    

    function fetchAllSentInvitationsByUserIds(int $user_id, bool $return_full_array = false, int $currentpage = 1, int $limit = 10, string $status = Connection::STATUS_ACCEPTED)
    {
        $select = $this->sql->select(self::_TABLE);
        $select->columns(['request_from']);
        $select->where->equalTo('request_from', $user_id)->and->equalTo('status',  $status);
        
        $invitations_array = [];
        $invitations = $this->executeFetchAllArray($select);
        if ($invitations) {
            for ($i = 0 , $max = count($invitations) ; $i < $max ; $i++)
            {
                $request_from = $invitations[$i]['request_to'];
                array_push($invitations_array, $request_from);
            }
        }
        if ($return_full_array) {
            $offset = ( $currentpage - 1 ) * $limit;
            $invitations_array = array_slice($invitations_array, $offset, $limit);
        }
        return $invitations_array;

    }
    
    /**
     * @param int $user1
     * @param int $user2
     * @return Connection
     */
    public function fetchOneByUserId1AndUserId2($user1, $user2)
    {
        $prototype = new Connection();
        $select = $this->sql->select(self::_TABLE);
        $select->where->and->nest()
        ->nest()
        ->equalTo('request_from', $user1)
        ->and->equalTo('request_to', $user2)
        ->unnest()
        ->or->nest()
        ->equalTo('request_to', $user1)
        ->and->equalTo('request_from', $user2)
        ->unnest()
        ->unnest();   

    
        return $this->executeFetchOneObject($select, $prototype);
    }
    
    
    /**
     *
     * @param int $user_id
     * @return int
     */
    public function fetchTotalConnectionByUser($user_id)
    {
        $select1 = $this->sql->select(self::_TABLE);
        $select1->columns(['total' => new Expression('COUNT(*)')]);
        $select1->where->equalTo('request_from', $user_id);
        $select1->where->equalTo('status', Connection::STATUS_ACCEPTED);
        
        $total = 0;
        $record = $this->executeFetchOneArray($select1);
        $total += $record['total'];
        
        $select2 = $this->sql->select(self::_TABLE);
        $select2->columns(['total' => new Expression('COUNT(*)')]);
        $select2->where->equalTo('request_to', $user_id);
        $select2->where->equalTo('status', Connection::STATUS_ACCEPTED);
        $record = $this->executeFetchOneArray($select2);
        $total += $record['total'];
  
        return  $total;
    }
    
    /**
     * 
     * @param int $user_id
     * @return Connection[]
     */
    public function fetchAllConnectionsByUser($user_id)
    {
        $prototype = new Connection();
        
        $select1 = $this->sql->select(self::_TABLE);
        $select1->where->equalTo('request_from', $user_id);
        $select1->where->equalTo('status', Connection::STATUS_ACCEPTED);
        
        $connections1 = $this->executeFetchAllObject($select1, $prototype);

        
        
        $select2 = $this->sql->select(self::_TABLE);
        $select2->columns(['user_id' => 'request_from']);
        $select2->where->equalTo('request_to', $user_id);
        $select2->where->equalTo('status', Connection::STATUS_ACCEPTED);
        
        $connections2 = $this->executeFetchAllObject($select2, $prototype);

        return array_merge($connections1, $connections2);
    }
    
    /**
     *
     * @param int $user_id
     * @return int[]
     */
    public function fetchAllConnectionsByUserReturnIds($user_id)
    {
        $user_ids = [];
        
        $select1 = $this->sql->select(self::_TABLE);
        $select1->columns(['request_to']);
        $select1->where->equalTo('request_from', $user_id);
        $select1->where->equalTo('status', Connection::STATUS_ACCEPTED);
        
        $connections = $this->executeFetchAllArray($select1);
        foreach($connections as $connection) 
        {
            array_push($user_ids, $connection['request_to']);
        }
        
        
        
        $select2 = $this->sql->select(self::_TABLE);
        $select2->columns(['user_id' => 'request_from']);
        $select2->where->equalTo('request_to', $user_id);
        $select2->where->equalTo('status', Connection::STATUS_ACCEPTED);
        
        $connections = $this->executeFetchAllArray($select2);
        foreach($connections as $connection)
        {
            array_push($user_ids, $connection['user_id']);
        }

        return $user_ids;
    }
    
    /**
     * 
     * @param int $user_id
     * @return int[]
     */
    function fetchAllSecondDegreeConnectionsForUserIdReturnIds($user_id) 
    {
        $user_ids = [];
        $connected_user_ids = $this->fetchAllConnectionsByUserReturnIds($user_id);
        

        if($connected_user_ids) {
            $select = $this->sql->select(self::_TABLE);
            $select->where->notEqualTo('request_from', $user_id)
            ->and->notEqualTo('request_to', $user_id)
            ->and->equalTo('status', Connection::STATUS_ACCEPTED)
            ->and->NEST->in('request_from', $connected_user_ids)->or->in('request_to', $connected_user_ids)->UNNEST;
            
            
            $connections = $this->executeFetchAllArray($select);
            foreach($connections as $connection)
            {
                $request_from   = $connection['request_from'];
                $request_to     = $connection['request_to'];
                if (in_array($request_from, $connected_user_ids)) {
                    $intermediate_user_id = $request_to;
                } else {
                    $intermediate_user_id = $request_from;
                }
                
                $checkIfRequestSent = $this->fetchOneByUserId1AndUserId2($intermediate_user_id, $user_id);
                if(!$checkIfRequestSent) {
                    
                    if(!in_array($intermediate_user_id, $user_ids)) {
                        array_push($user_ids, $intermediate_user_id);
                    }
                }
            }
        }
        return $user_ids;
    }
    
    /**
     * 
     * @param int $first_user_id
     * @param int $second_user_id
     * @return int[]
     */
    function fetchAllCommonConnectionsUserIdByUser1ReturnIds($first_user_id, $second_user_id)
    {
        $first_user_connections     = $this->fetchAllConnectionsByUserReturnIds($first_user_id);
        $second_user_connections    = $this->fetchAllConnectionsByUserReturnIds($second_user_id);
        
        return array_values(array_intersect($first_user_connections, $second_user_connections));
    }
    
    /**
     *
     * @param int $user_id
     * @return int[]
     */
    public function fetchAllSentsUserIdForUser($user_id)
    {
        $prototype = new Connection();
        
        $select = $this->sql->select(self::_TABLE);
        $select->where->equalTo('request_to', $user_id);
        $select->where->equalTo('status', Connection::STATUS_SENT);
        
        $connections = $this->executeFetchAllObject($select, $prototype);
        
        
        
        $user_ids = [];
        foreach($connections as $connection)
        {
            array_push($user_ids, $connection->request_from);
        }
        
        return $user_ids;
    }
    
    /**
     *
     * @param int $user_id
     * @return int[]
     */
    public function fetchAllReceiveInvitationsReturnIds($user_id)
    {
        $select = $this->sql->select(self::_TABLE);
        $select->columns(['request_from']);
        $select->where->equalTo('request_to', $user_id)->and->equalTo('status', Connection::STATUS_SENT);
        
        //echo $select->getSqlString($this->adapter->platform); exit;
        
        $user_ids  = [];
        $records = $this->executeFetchAllArray($select);
        foreach($records as $record)
        {
            array_push($user_ids, (int)  $record['request_from']);
        }
        return $user_ids;
    }
    
    
    /**
     * 
     * @param int $user_id
     * @return int[]
     */
    public function fetchAllSentInvitationsReturnIds($user_id)
    {
        $select = $this->sql->select(self::_TABLE);
        $select->columns(['request_to']);
        $select->where->equalTo('request_from', $user_id)->and->equalTo('status', Connection::STATUS_SENT);
        
        $user_ids  = [];
        $records = $this->executeFetchAllArray($select);
        foreach($records as $record)
        {
            array_push($user_ids, (int)  $record['request_to']);
        }
        return $user_ids;
    }
    
    /**
     * 
     * @param int $user_id
     * @return int
     */
    public function fetchConnectionRequestCount($user_id)
    {
        $select = $this->sql->select(self::_TABLE);
        $select->columns(['total' => new Expression('COUNT(*)')]);
        $select->where->equalTo('request_to', $user_id)->and->equalTo('status', Connection::STATUS_SENT);
        
        $record = $this->executeFetchOneArray($select);
        return $record['total'];
    }
    
    /**
     *
     * @param Connection $connection
     * @return boolean
     */
    public function approve($connection) 
    {
        $update = $this->sql->update(self::_TABLE);
        $update->set(['status' => Connection::STATUS_ACCEPTED]);
        $update->where->equalTo('id', $connection->id);
        
        return $this->executeUpdate($update);
    }
    
        
    /**
     *
     * @param Connection $connection
     * @return boolean
     */
    public function reject($connection)
    {
        $update = $this->sql->update(self::_TABLE);
        $update->set(['status' => Connection::STATUS_REJECTED]);
        $update->where->equalTo('id', $connection->id);
        
        return $this->executeUpdate($update);
    }
    
    /**
     * 
     * @param Connection $connection
     * @return boolean
     */
    public function cancel($connection)
    {
        $update = $this->sql->update(self::_TABLE);
        $update->set(['status' => Connection::STATUS_CANCELLED]);
        $update->where->equalTo('id', $connection->id);
        
        return $this->executeUpdate($update);
   
    }
    
    
    /**
     *
     * @param Connection $connection
     * @return boolean
     */
    public function delete($connection)
    {
        $delete = $this->sql->delete(self::_TABLE);
        $delete->where->equalTo('id', $connection->id);
        
        return $this->executeDelete($delete);
        
    }
    
    
    /**
     *
     * @param Connection $connection
     * @return boolean
     */
    public function update($connection)
    {
        $hydrator = new ObjectPropertyHydrator();
        $values = $hydrator->extract($connection);
        $values = $this->removeEmpty($values);
        
        $update = $this->sql->update(self::_TABLE);
        $update->set($values);
        $update->where->equalTo('id', $connection->id);
        
        return $this->executeUpdate($update);
        
    }
    
    /**
     * 
     * @param int $user_id
     * @return int[]
     */
    public function getSecondDegreeConnectionsReturnIds($user_id)
    {
        $connected_uses_ids_array = $this->fetchAllConnectionsByUserReturnIds($user_id);

        $user_ids_array = [];
        if ($connected_uses_ids_array) {
                
            $queryMapper = QueryMapper::getInstance($this->adapter);
            $select = $queryMapper->getSql()->select(ConnectionMapper::_TABLE);
            $select->columns(['request_from', 'request_to']);
            $select->where->equalTo('status', Connection::STATUS_ACCEPTED)
            ->and->notEqualTo('request_from', $user_id)
            ->and->notEqualTo('request_to', $user_id)
            ->and->nest()->in('request_from',$connected_uses_ids_array)->or->in('request_to',$connected_uses_ids_array)->unnest();
                
                
            $connections = $queryMapper->fetchAll($select);
            if ($connections) {
                foreach ($connections as $connection) {
                    $request_from   = $connection['request_from'];
                    $request_to     = $connection['request_to'];
                    if (in_array($request_from, $connected_uses_ids_array)) {
                        $intermediate_user_id = $request_to;
                    } else {
                        $intermediate_user_id = $request_from;
                    }
                    if (!in_array($intermediate_user_id, $user_ids_array)) {
                        $select = $queryMapper->getSql()->select(ConnectionMapper::_TABLE);
                         $select->columns(['request_from', 'request_to']);
                         $select->where->nest()->equalTo('request_from', $user_id)->and->equalTo('request_to', $intermediate_user_id)->unnest()
                         ->or->nest()->equalTo('request_from', $intermediate_user_id)->and->equalTo('request_to', $user_id)->unnest();
                            
                         $checkIfRequestSent = $queryMapper->fetchOne($select);
                         if (!$checkIfRequestSent) {
                             array_push($user_ids_array, $intermediate_user_id);
                        }
                    }
                }
            }
        }
        return $user_ids_array;
    }
    
    /**
     * 
     * @param Connection $connection
     * @return boolean
     */
    public function insert($connection)
    {
        $hydrator = new ObjectPropertyHydrator();
        $values = $hydrator->extract($connection);
        $values = $this->removeEmpty($values);
        
        $insert = $this->sql->insert(self::_TABLE);
        $insert->values($values);
        
        $response = $this->executeInsert($insert);
        if($response) {
            $connection->id = $this->lastInsertId;
        }
        
        return $response;
    }
    

    
}