src/Contact/Introduction/Depository/Introduction.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2010-2021, the Friendica project
   4  *
   5  * @license GNU AGPL version 3 or any later version
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as
   9  * published by the Free Software Foundation, either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 namespace Friendica\Contact\Introduction\Depository;
  23
  24 use Friendica\BaseDepository;
  25 use Friendica\Contact\Introduction\Exception\IntroductionNotFoundException;
  26 use Friendica\Contact\Introduction\Exception\IntroductionPersistenceException;
  27 use Friendica\Contact\Introduction\Collection;
  28 use Friendica\Contact\Introduction\Entity;
  29 use Friendica\Contact\Introduction\Factory;
  30 use Friendica\Database\Database;
  31 use Friendica\Network\HTTPException\NotFoundException;
  32 use Friendica\Util\DateTimeFormat;
  33 use Psr\Log\LoggerInterface;
  34
  35 class Introduction extends BaseDepository
  36 {
  37         /** @var Factory\Introduction */
  38         protected $factory;
  39
  40         protected static $table_name = 'intro';
  41
  42         public function __construct(Database $database, LoggerInterface $logger, Factory\Introduction $factory)
  43         {
  44                 parent::__construct($database, $logger, $factory);
  45         }
  46
  47         /**
  48          * @param array $condition
  49          * @param array $params
  50          *
  51          * @return Entity\Introduction
  52          *
  53          * @throws NotFoundException the underlying exception if there's no Introduction with the given conditions
  54          */
  55         private function selectOne(array $condition, array $params = []): Entity\Introduction
  56         {
  57                 return parent::_selectOne($condition, $params);
  58         }
  59
  60         /**
  61          * Converts a given Introduction into a DB compatible row array
  62          *
  63          * @param Entity\Introduction $introduction
  64          *
  65          * @return array
  66          */
  67         protected function convertToTableRow(Entity\Introduction $introduction): array
  68         {
  69                 return [
  70                         'uid'         => $introduction->uid,
  71                         'fid'         => $introduction->fid,
  72                         'contact-id'  => $introduction->cid,
  73                         'suggest-cid' => $introduction->sid,
  74                         'knowyou'     => $introduction->knowyou ? 1 : 0,
  75                         'duplex'      => $introduction->duplex ? 1 : 0,
  76                         'note'        => $introduction->note,
  77                         'hash'        => $introduction->hash,
  78                         'blocked'     => $introduction->blocked ? 1 : 0,
  79                         'ignore'      => $introduction->ignore ? 1 : 0,
  80                         'datetime'    => $introduction->datetime->format(DateTimeFormat::MYSQL),
  81                 ];
  82         }
  83
  84         /**
  85          * @param int $id
  86          * @param int $uid
  87          *
  88          * @return Entity\Introduction
  89          *
  90          * @throws IntroductionNotFoundException in case there is no Introduction with this id
  91          */
  92         public function selectOneById(int $id, int $uid): Entity\Introduction
  93         {
  94                 try {
  95                         return $this->selectOne(['id' => $id, 'uid' => $uid]);
  96                 } catch (NotFoundException $exception) {
  97                         throw new IntroductionNotFoundException(sprintf('There is no Introduction with the ID %d for the user %d', $id, $uid), $exception);
  98                 }
  99         }
 100
 101         /**
 102          * Selects introductions for a given user
 103          *
 104          * @param int      $uid
 105          * @param int|null $min_id
 106          * @param int|null $max_id
 107          * @param int      $limit
 108          *
 109          * @return Collection\Introductions
 110          */
 111         public function selectForUser(int $uid, int $min_id = null, int $max_id = null, int $limit = self::LIMIT): Collection\Introductions
 112         {
 113                 try {
 114                         $BaseCollection = parent::_selectByBoundaries(
 115                                 ['`uid = ?` AND NOT `ignore`',$uid],
 116                                 ['order' => ['id' => 'DESC']],
 117                                 $min_id, $max_id, $limit);
 118                 } catch (\Exception $e) {
 119                         throw new IntroductionPersistenceException(sprintf('Cannot select Introductions for used %d', $uid), $e);
 120                 }
 121
 122                 return new Collection\Introductions($BaseCollection->getArrayCopy(), $BaseCollection->getTotalCount());
 123         }
 124
 125         /**
 126          * Selects the introduction for a given contact
 127          *
 128          * @param int $cid
 129          *
 130          * @return Entity\Introduction
 131          *
 132          * @throws IntroductionNotFoundException in case there is not Introduction for this contact
 133          */
 134         public function selectForContact(int $cid): Entity\Introduction
 135         {
 136                 try {
 137                         return $this->selectOne(['contact-id' => $cid]);
 138                 } catch (NotFoundException $exception) {
 139                         throw new IntroductionNotFoundException(sprintf('There is no Introduction for the contact %d', $cid), $exception);
 140                 }
 141         }
 142
 143         public function countActiveForUser($uid, array $params = []): int
 144         {
 145                 try {
 146                         return $this->count(['blocked' => false, 'ignore' => false, 'uid' => $uid], $params);
 147                 } catch (\Exception $e) {
 148                         throw new IntroductionPersistenceException(sprintf('Cannot count Introductions for used %d', $uid), $e);
 149                 }
 150         }
 151
 152         public function existsForContact(int $cid, int $uid): bool
 153         {
 154                 try {
 155                         return $this->exists(['uid' => $uid, 'suggest-cid' => $cid]);
 156                 } catch (\Exception $e) {
 157                         throw new IntroductionPersistenceException(sprintf('Cannot check Introductions for contact %d and user %d', $cid, $uid), $e);
 158                 }
 159         }
 160
 161         /**
 162          * @param Entity\Introduction $introduction
 163          *
 164          * @return bool
 165          *
 166          * @throws IntroductionPersistenceException in case the underlying storage cannot delete the Introduction
 167          */
 168         public function delete(Entity\Introduction $introduction): bool
 169         {
 170                 if (!$introduction->id) {
 171                         return false;
 172                 }
 173
 174                 try {
 175                         return $this->db->delete(self::$table_name, ['id' => $introduction->id]);
 176                 } catch (\Exception $e) {
 177                         throw new IntroductionPersistenceException(sprintf('Cannot delete Introduction with id %d', $introduction->id), $e);
 178                 }
 179         }
 180
 181         /**
 182          * @param Entity\Introduction $introduction
 183          *
 184          * @return Entity\Introduction
 185          *
 186          * @throws IntroductionPersistenceException In case the underlying storage cannot save the Introduction
 187          */
 188         public function save(Entity\Introduction $introduction): Entity\Introduction
 189         {
 190                 try {
 191                         $fields = $this->convertToTableRow($introduction);
 192
 193                         if ($introduction->id) {
 194                                 $this->db->update(self::$table_name, $fields, ['id' => $introduction->id]);
 195                                 return $this->factory->createFromTableRow($fields);
 196                         } else {
 197                                 $this->db->insert(self::$table_name, $fields);
 198                                 return $this->selectOneById($this->db->lastInsertId(), $introduction->uid);
 199                         }
 200                 } catch (\Exception $exception) {
 201                         throw new IntroductionPersistenceException(sprintf('Cannot insert/update the Introduction %d for user %d', $introduction->id, $introduction->uid), $exception);
 202                 }
 203         }
 204 }