AccountManager::getProxy() - Code Metrics - Inspection of "add: account history command" - jakim/ig-monitoring - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 0db423...f9fe2f )

by Paweł

created 2018-03-19 19:31 UTC

AccountManager::getProxy() A

↳ Parent: AccountManager

Complexity

Conditions	4
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	4
nc	2
nop	1
dl	0
loc	8
rs	9.2
c	0
b	0
f	0

<?php
/**
 * Created for IG Monitoring.
 * User: jakim <[email protected]>
 * Date: 11.01.2018
 */

namespace app\components;


use app\components\http\Client;
use app\components\http\CacheStorage;
use app\models\Account;
use app\models\AccountStats;
use app\models\AccountTag;
use app\models\Media;
use app\models\Proxy;
use app\models\Tag;
use GuzzleHttp\HandlerStack;
use Jakim\Query\AccountQuery;
use Kevinrob\GuzzleCache\CacheMiddleware;
use Kevinrob\GuzzleCache\Strategy\GreedyCacheStrategy;
use yii\base\Component;
use yii\base\InvalidConfigException;

class AccountManager extends Component
{
    /**
     * @var Proxy
     */
    public $proxy;

    public function fetchDetails(Account $account): \Jakim\Model\Account
    {
        $query = $this->queryFactory($account);

        return $query->findOne($account->username);
    }

    /**
     * Fetch data from API, update details and stats.
     *
     * @param \app\models\Account $account
     * @return \app\models\Account
     */
    public function update(Account $account)
    {
        $data = $this->fetchDetails($account);
        $this->updateDetails($account, $data);
        $this->updateStats($account, $data);

        return $account;
    }

    public function updateDetails(Account $account, \Jakim\Model\Account $data = null): Account
    {
        $data = $data ?: $this->fetchDetails($account);

        $account->profile_pic_url = $data->profilePicUrl;
        $account->full_name = $data->fullName;
        $account->biography = $data->biography;
        $account->external_url = $data->externalUrl;
        $account->instagram_id = $data->id;

        $this->updateProfilePic($account);

        $account->save();

        return $account;
    }

    public function updateStats(Account $account, \Jakim\Model\Account $data = null): ?AccountStats
    {
        $data = $data ?: $this->fetchDetails($account);
        $accountStats = null;

        if ($this->statsNeedUpdate($account, $data)) {
            $accountStats = new AccountStats();
            $accountStats->followed_by = $data->followedBy;
            $accountStats->follows = $data->follows;
            $accountStats->media = $data->media;
            $account->link('accountStats', $accountStats);
            $account->resetStatsCache();
        }
        $this->updateMedia($account);
        $this->updateEr($account);

        return $accountStats;
    }

    protected function updateEr(Account $account, int $mediaLimit = 10)
    {
        if (!$account->lastAccountStats) {
            return false;
        }

        $media = Media::find()
            ->innerJoinWith('mediaStats')
            ->andWhere(['account_id' => $account->id])
            ->limit($mediaLimit)
            ->groupBy('media.id')
            ->all();

        $er = [];
        foreach ($media as $m) {
            $er[] = ($m->lastMediaStats->likes + $m->lastMediaStats->comments) / $m->lastMediaStats->account_followed_by;
        }

        $er = $er ? array_sum($er) / count($er) : 0;
        $account->lastAccountStats->er = round($er, 4);

        return $account->lastAccountStats->update();
    }

    public function updateMedia(Account $account, int $limit = 10)
    {
        $manager = \Yii::createObject([
            'class' => MediaManager::class,
            'account' => $account,
        ]);

        $query = $this->queryFactory($account);
        $items = $query->findPosts($account->username, $limit);

        foreach ($items as $item) {
            $media = Media::findOne(['instagram_id' => $item->id]);
            if ($media === null) {
                $media = new Media(['account_id' => $account->id]);
            }
            $manager->update($media, $item);
        }
    }

    public function updateTags(Account $account, array $tags)
    {
        // clearing
        AccountTag::deleteAll(['account_id' => $account->id]);

        // add
        foreach (array_filter($tags) as $tag) {
            $model = Tag::findOne(['name' => $tag]);
            if ($model === null && $tag) {
                $model = new Tag(['name' => $tag]);
                $model->insert();
            }
            $account->link('tags', $model);
        }
    }

    public function saveUsernames(array $usernames)
    {
        $createdAt = (new \DateTime())->format('Y-m-d H:i:s');
        $rows = array_map(function ($username) use ($createdAt) {
            return [
                $username,
                $createdAt,
                $createdAt,
            ];
        }, $usernames);

        $sql = \Yii::$app->db->getQueryBuilder()
            ->batchInsert(Account::tableName(), ['username', 'updated_at', 'created_at'], $rows);
        $sql = str_replace('INSERT INTO ', 'INSERT IGNORE INTO ', $sql);
        \Yii::$app->db->createCommand($sql)
            ->execute();
    }

    protected function getProxy(Account $account): Proxy
    {
        $proxy = $this->proxy ?: $account->proxy;
        if (!$proxy || !$proxy->active) {
            throw new InvalidConfigException('Account proxy must be set and be active.');
        }

        return $proxy;
    }

    protected function updateProfilePic(Account $account): void
    {
        if ($account->profile_pic_url) {
            $url = $account->profile_pic_url;
            $account->profile_pic_url = null;

            $filename = sprintf('%s_%s', $account->username, basename($url));
            $path = \Yii::getAlias("@app/web/uploads/{$filename}");
            $fileExists = file_exists($path);

            if (!$fileExists) {
                $proxy = $this->getProxy($account);
                $client = Client::factory($proxy);
                $content = $client->get($url)->getBody()->getContents();
                if ($content && file_put_contents($path, $content)) {
                    $account->profile_pic_url = "/uploads/{$filename}";
                }
            } elseif ($fileExists) {

                $account->profile_pic_url = "/uploads/{$filename}";
            }
        }
    }

    private function statsNeedUpdate(Account $account, \Jakim\Model\Account $data): bool
    {
        if (!$account->lastAccountStats) {
            return true;
        }

        return $account->lastAccountStats->followed_by != $data->followedBy ||
            $account->lastAccountStats->follows != $data->follows ||
            $account->lastAccountStats->media != $data->media;
    }

    /**
     * @param \app\models\Account $account
     * @return AccountQuery
     * @throws \yii\base\InvalidConfigException
     */
    private function queryFactory(Account $account): AccountQuery
    {
        $proxy = $this->getProxy($account);

//        $stack = HandlerStack::create();
//        $stack->push(new CacheMiddleware(
//            new GreedyCacheStrategy(
//                new CacheStorage(), 3600)
//        ), 'cache');
//        $client = Client::factory($proxy, ['handler' => $stack]);
        $client = Client::factory($proxy);

        $query = new AccountQuery($client);

        return $query;
    }
}

1			<?php
2			/**
3			* Created for IG Monitoring.
4			* User: jakim <[email protected]>
5			* Date: 11.01.2018
6			*/
7
8			namespace app\components;
9
10
11			use app\components\http\Client;
12			use app\components\http\CacheStorage;
13			use app\models\Account;
14			use app\models\AccountStats;
15			use app\models\AccountTag;
16			use app\models\Media;
17			use app\models\Proxy;
18			use app\models\Tag;
19			use GuzzleHttp\HandlerStack;
20			use Jakim\Query\AccountQuery;
21			use Kevinrob\GuzzleCache\CacheMiddleware;
22			use Kevinrob\GuzzleCache\Strategy\GreedyCacheStrategy;
23			use yii\base\Component;
24			use yii\base\InvalidConfigException;
25
26			class AccountManager extends Component
27			{
28			/**
29			* @var Proxy
30			*/
31			public $proxy;
32
33			public function fetchDetails(Account $account): \Jakim\Model\Account
34			{
35			$query = $this->queryFactory($account);
36
37			return $query->findOne($account->username);
38			}
39
40			/**
41			* Fetch data from API, update details and stats.
42			*
43			* @param \app\models\Account $account
44			* @return \app\models\Account
45			*/
46			public function update(Account $account)
47			{
48			$data = $this->fetchDetails($account);
49			$this->updateDetails($account, $data);
50			$this->updateStats($account, $data);
51
52			return $account;
53			}
54
55			public function updateDetails(Account $account, \Jakim\Model\Account $data = null): Account
56			{
57			$data = $data ?: $this->fetchDetails($account);
58
59			$account->profile_pic_url = $data->profilePicUrl;
60			$account->full_name = $data->fullName;
61			$account->biography = $data->biography;
62			$account->external_url = $data->externalUrl;
63			$account->instagram_id = $data->id;
64
65			$this->updateProfilePic($account);
66
67			$account->save();
68
69			return $account;
70			}
71
72			public function updateStats(Account $account, \Jakim\Model\Account $data = null): ?AccountStats
73			{
74			$data = $data ?: $this->fetchDetails($account);
75			$accountStats = null;
76
77			if ($this->statsNeedUpdate($account, $data)) {
78			$accountStats = new AccountStats();
79			$accountStats->followed_by = $data->followedBy;
80			$accountStats->follows = $data->follows;
81			$accountStats->media = $data->media;
82			$account->link('accountStats', $accountStats);
83			$account->resetStatsCache();
84			}
85			$this->updateMedia($account);
86			$this->updateEr($account);
87
88			return $accountStats;
89			}
90
91			protected function updateEr(Account $account, int $mediaLimit = 10)
92			{
93			if (!$account->lastAccountStats) {
94			return false;
95			}
96
97			$media = Media::find()
98			->innerJoinWith('mediaStats')
99			->andWhere(['account_id' => $account->id])
100			->limit($mediaLimit)
101			->groupBy('media.id')
102			->all();
103
104			$er = [];
105			foreach ($media as $m) {
106			$er[] = ($m->lastMediaStats->likes + $m->lastMediaStats->comments) / $m->lastMediaStats->account_followed_by;
107			}
108
109			$er = $er ? array_sum($er) / count($er) : 0;
110			$account->lastAccountStats->er = round($er, 4);
111
112			return $account->lastAccountStats->update();
113			}
114
115			public function updateMedia(Account $account, int $limit = 10)
116			{
117			$manager = \Yii::createObject([
118			'class' => MediaManager::class,
119			'account' => $account,
120			]);
121
122			$query = $this->queryFactory($account);
123			$items = $query->findPosts($account->username, $limit);
124
125			foreach ($items as $item) {
126			$media = Media::findOne(['instagram_id' => $item->id]);
127			if ($media === null) {
128			$media = new Media(['account_id' => $account->id]);
129			}
130			$manager->update($media, $item);
131			}
132			}
133
134			public function updateTags(Account $account, array $tags)
135			{
136			// clearing
137			AccountTag::deleteAll(['account_id' => $account->id]);
138
139			// add
140			foreach (array_filter($tags) as $tag) {
141			$model = Tag::findOne(['name' => $tag]);
142			if ($model === null && $tag) {
143			$model = new Tag(['name' => $tag]);
144			$model->insert();
145			}
146			$account->link('tags', $model);
147			}
148			}
149
150			public function saveUsernames(array $usernames)
151			{
152			$createdAt = (new \DateTime())->format('Y-m-d H:i:s');
153			$rows = array_map(function ($username) use ($createdAt) {
154			return [
155			$username,
156			$createdAt,
157			$createdAt,
158			];
159			}, $usernames);
160
161			$sql = \Yii::$app->db->getQueryBuilder()
162			->batchInsert(Account::tableName(), ['username', 'updated_at', 'created_at'], $rows);
163			$sql = str_replace('INSERT INTO ', 'INSERT IGNORE INTO ', $sql);
164			\Yii::$app->db->createCommand($sql)
165			->execute();
166			}
167
168			protected function getProxy(Account $account): Proxy
169			{
170			$proxy = $this->proxy ?: $account->proxy;
171			if (!$proxy \|\| !$proxy->active) {
172			throw new InvalidConfigException('Account proxy must be set and be active.');
173			}
174
175			return $proxy;
176			}
177
178			protected function updateProfilePic(Account $account): void
179			{
180			if ($account->profile_pic_url) {
181			$url = $account->profile_pic_url;
182			$account->profile_pic_url = null;
183
184			$filename = sprintf('%s_%s', $account->username, basename($url));
185			$path = \Yii::getAlias("@app/web/uploads/{$filename}");
186			$fileExists = file_exists($path);
187
188			if (!$fileExists) {
189			$proxy = $this->getProxy($account);
190			$client = Client::factory($proxy);
191			$content = $client->get($url)->getBody()->getContents();
192			if ($content && file_put_contents($path, $content)) {
193			$account->profile_pic_url = "/uploads/{$filename}";
194			}
195			} elseif ($fileExists) {
			0 ignored issues – show introduced 2018-03-11 06:25 UTC by Report Bug Copy Issue Report The condition `$fileExists` is always `true`. Loading history...
196			$account->profile_pic_url = "/uploads/{$filename}";
197			}
198			}
199			}
200
201			private function statsNeedUpdate(Account $account, \Jakim\Model\Account $data): bool
202			{
203			if (!$account->lastAccountStats) {
204			return true;
205			}
206
207			return $account->lastAccountStats->followed_by != $data->followedBy \|\|
208			$account->lastAccountStats->follows != $data->follows \|\|
209			$account->lastAccountStats->media != $data->media;
210			}
211
212			/**
213			* @param \app\models\Account $account
214			* @return AccountQuery
215			* @throws \yii\base\InvalidConfigException
216			*/
217			private function queryFactory(Account $account): AccountQuery
218			{
219			$proxy = $this->getProxy($account);
220
221			// $stack = HandlerStack::create();
222			// $stack->push(new CacheMiddleware(
223			// new GreedyCacheStrategy(
224			// new CacheStorage(), 3600)
225			// ), 'cache');
226			// $client = Client::factory($proxy, ['handler' => $stack]);
227			$client = Client::factory($proxy);
228
229			$query = new AccountQuery($client);
230
231			return $query;
232			}
233			}

jakim / ig-monitoring

Push — master ( 0db423...f9fe2f )

AccountManager::getProxy() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like