Strime\Slackify\Api\Reactions

Complexity

Total Complexity

61

Size/Duplication

Total Lines	267
Duplicated Lines	41.2 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
C	add()	55	55	16
D	get()	0	56	18
B	list_reactions()	0	47	11
C	remove()	55	55	16

<?php

/*
 * This file is part of Slackify.
 *
 * (c) Strime <contact@strime.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Strime\Slackify\Api;

use Strime\Slackify\Exception\RuntimeException;
use Strime\Slackify\Exception\InvalidArgumentException;
use GuzzleHttp\Exception\RequestException;

class Reactions extends AbstractApi
{
    /**
     * {@inheritdoc}
     *
     * @param  string $name
     * @param  string $file
     * @param  string $file_comment
     * @param  string $channel
     * @param  float $timestamp
     * @return Reactions
     */
    public function add($name, $file = NULL, $file_comment = NULL, $channel = NULL, $timestamp = NULL) {

This method seems to be duplicated in your project.

        // Check if the type of the variables is valid.
        if (!is_string($name)) {
            throw new InvalidArgumentException("The type of the name variable is not valid.");
        }
        if (($file != NULL) && !is_string($file)) {

It seems like you are loosely comparing $file of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            throw new InvalidArgumentException("The type of the file variable is not valid.");
        }
        if (($file_comment != NULL) && !is_string($file_comment)) {

It seems like you are loosely comparing $file_comment of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            throw new InvalidArgumentException("The type of the file_comment variable is not valid.");
        }
        if (($channel != NULL) && !is_string($channel)) {

It seems like you are loosely comparing $channel of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            throw new InvalidArgumentException("The type of the channel variable is not valid.");
        }
        if (($timestamp != NULL) && !is_float($timestamp)) {
            throw new InvalidArgumentException("The type of the timestamp variable is not valid.");
        }

        // Set the arguments of the request
        $arguments = array(
            "name" => $name
        );

        if ($file != NULL) {

It seems like you are loosely comparing $file of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $arguments["file"] = $file;
        }
        if ($file_comment != NULL) {

It seems like you are loosely comparing $file_comment of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $arguments["file_comment"] = $file_comment;
        }
        if ($channel != NULL) {

It seems like you are loosely comparing $channel of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $arguments["channel"] = $channel;
        }
        if ($timestamp != NULL) {
            $arguments["timestamp"] = (float)$timestamp;
        }

        $this->setUrl("reactions.add", $arguments);

        // Send the request
        try {
            $client = new \GuzzleHttp\Client();
            $json_response = $client->request('GET', $this->getUrl(), []);
            $response = json_decode( $json_response->getBody() );
        }
        catch (RequestException $e) {
            throw new RuntimeException('The request to the API failed: '.$e->getMessage(), $e->getCode(), $e);
        }

        if($response->{'ok'} === FALSE) {
            throw new RuntimeException('The request to the API failed: '.$response->{'error'}.".");
        }

        return $this;
    }




    /**
     * {@inheritdoc}
     *
     * @param  string $file
     * @param  string $file_comment
     * @param  string $channel
     * @param  float $timestamp
     * @param  boolean $full
     * @return Reactions
     */
    public function get($file = NULL, $file_comment = NULL, $channel = NULL, $timestamp = NULL, $full = NULL) {

        // Check if the type of the variables is valid.
        if (($file != NULL) && !is_string($file)) {

It seems like you are loosely comparing $file of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            throw new InvalidArgumentException("The type of the file variable is not valid.");
        }
        if (($file_comment != NULL) && !is_string($file_comment)) {

It seems like you are loosely comparing $file_comment of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            throw new InvalidArgumentException("The type of the file_comment variable is not valid.");
        }
        if (($channel != NULL) && !is_string($channel)) {

It seems like you are loosely comparing $channel of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            throw new InvalidArgumentException("The type of the channel variable is not valid.");
        }
        if (($timestamp != NULL) && !is_float($timestamp)) {
            throw new InvalidArgumentException("The type of the timestamp variable is not valid.");
        }
        if (($full != NULL) && !is_bool($full)) {
            throw new InvalidArgumentException("The type of the full variable is not valid.");
        }

        // Set the arguments of the request
        $arguments = array();

        if ($file != NULL) {

It seems like you are loosely comparing $file of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $arguments["file"] = $file;
        }
        if ($file_comment != NULL) {

It seems like you are loosely comparing $file_comment of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $arguments["file_comment"] = $file_comment;
        }
        if ($channel != NULL) {

It seems like you are loosely comparing $channel of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $arguments["channel"] = $channel;
        }
        if ($timestamp != NULL) {
            $arguments["timestamp"] = (string)$timestamp;
        }
        if ($full != NULL) {
            $arguments["full"] = $full;
        }

        $this->setUrl("reactions.get", $arguments);

        // Send the request
        try {
            $client = new \GuzzleHttp\Client();
            $json_response = $client->request('GET', $this->getUrl(), []);
            $response = json_decode( $json_response->getBody() );
        }
        catch (RequestException $e) {
            throw new RuntimeException('The request to the API failed: '.$e->getMessage(), $e->getCode(), $e);
        }

        if($response->{'ok'} === FALSE) {
            throw new RuntimeException('The request to the API failed: '.$response->{'error'}.".");
        }

        return $json_response->getBody();
    }




    /**
     * {@inheritdoc}
     *
     * @param  string $user
     * @param  boolean $full
     * @param  string $count
     * @param  string $page
     * @return Reactions
     */
    public function list_reactions($user = NULL, $full = NULL, $count = 100, $page = 1) {

        // Check if the type of the variables is valid.
        if (($user != NULL) && !is_string($user)) {

It seems like you are loosely comparing $user of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            throw new InvalidArgumentException("The type of the user variable is not valid.");
        }
        if (($full != NULL) && !is_bool($full)) {
            throw new InvalidArgumentException("The type of the full variable is not valid.");
        }
        if (!is_integer($count)) {
            throw new InvalidArgumentException("The type of the count variable is not valid.");
        }
        if (!is_integer($page)) {
            throw new InvalidArgumentException("The type of the page variable is not valid.");
        }

        // Set the arguments of the request
        $arguments = array(
            "count" => $count,
            "page" => $page
        );

        if($user != NULL) {

It seems like you are loosely comparing $user of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $arguments["user"] = $user;
        }
        if($full != NULL) {
            $arguments["full"] = $full;
        }

        $this->setUrl("reactions.list");

        // Send the request
        try {
            $client = new \GuzzleHttp\Client();
            $json_response = $client->request('GET', $this->getUrl(), []);
            $response = json_decode( $json_response->getBody() );
        }
        catch (RequestException $e) {
            throw new RuntimeException('The request to the API failed: '.$e->getMessage(), $e->getCode(), $e);
        }

        if($response->{'ok'} === FALSE) {
            throw new RuntimeException('The request to the API failed: '.$response->{'error'}.".");
        }

        return $json_response->getBody();
    }




    /**
     * {@inheritdoc}
     *
     * @param  string $name
     * @param  string $file
     * @param  string $file_comment
     * @param  string $channel
     * @param  float $timestamp
     * @return Reactions
     */
    public function remove($name, $file = NULL, $file_comment = NULL, $channel = NULL, $timestamp = NULL) {

This method seems to be duplicated in your project.

        // Check if the type of the variables is valid.
        if (!is_string($name)) {
            throw new InvalidArgumentException("The type of the name variable is not valid.");
        }
        if (($file != NULL) && !is_string($file)) {

It seems like you are loosely comparing $file of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            throw new InvalidArgumentException("The type of the file variable is not valid.");
        }
        if (($file_comment != NULL) && !is_string($file_comment)) {

It seems like you are loosely comparing $file_comment of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            throw new InvalidArgumentException("The type of the file_comment variable is not valid.");
        }
        if (($channel != NULL) && !is_string($channel)) {

It seems like you are loosely comparing $channel of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            throw new InvalidArgumentException("The type of the channel variable is not valid.");
        }
        if (($timestamp != NULL) && !is_float($timestamp)) {
            throw new InvalidArgumentException("The type of the timestamp variable is not valid.");
        }

        // Set the arguments of the request
        $arguments = array(
            "name" => $name
        );

        if ($file != NULL) {

It seems like you are loosely comparing $file of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $arguments["file"] = $file;
        }
        if ($file_comment != NULL) {

It seems like you are loosely comparing $file_comment of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $arguments["file_comment"] = $file_comment;
        }
        if ($channel != NULL) {

It seems like you are loosely comparing $channel of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $arguments["channel"] = $channel;
        }
        if ($timestamp != NULL) {
            $arguments["timestamp"] = (string)$timestamp;
        }

        $this->setUrl("reactions.remove", $arguments);

        // Send the request
        try {
            $client = new \GuzzleHttp\Client();
            $json_response = $client->request('GET', $this->getUrl(), []);
            $response = json_decode( $json_response->getBody() );
        }
        catch (RequestException $e) {
            throw new RuntimeException('The request to the API failed: '.$e->getMessage(), $e->getCode(), $e);
        }

        if($response->{'ok'} === FALSE) {
            throw new RuntimeException('The request to the API failed: '.$response->{'error'}.".");
        }

        return $this;
    }
}