StatementForward::updateStatementForwardQuery() - Code Metrics - ijeffro/laralocker - Measure and Improve Code Quality continuously with Scrutinizer

StatementForward::updateStatementForwardQuery() A
last analyzed 2019-11-28 14:53 UTC

↳ Parent: StatementForward
Complexity

Conditions	5
Paths	5
Size

Total Lines	8
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
eloc	5
c	2
b	0
f	0
dl	0
loc	8
rs	9.6111
cc	5
nc	5
nop	2
<?php
namespace HT2\Integrations\LearningLocker;

use Guzzle\Exception\RequestException;
filter:
    dependency_paths: ["lib/*"]
use Curatr\Services\LearningLocker as LLService;
filter:
    dependency_paths: ["lib/*"]
use Lcobucci\JWT\Builder;
use Lcobucci\JWT\Signer\Hmac\Sha256;
use \Exception;

class StatementForward extends Connection {
filter:
    dependency_paths: ["lib/*"]

  private $statementForward = '/statementforwarding';
  private $api = '/api';
  private $v2 = '/v2';

  private $headers = [
    'content-type' => 'application/json'
  ];

  /**
   * Generate the Query for Learning Locker's
   * Statement Forward.
   *
   * @return  true
   * @return  false
   */
  public function updateStatementForwardQuery($statementForwardId, $isEnabled) {
    $query = Query::statementForward($this->org->id);
filter:
    dependency_paths: ["lib/*"]
    if ($query === false || !$isEnabled) {
      $message = $query === false && $isEnabled ? '(No objects)' : null;
      return $this->disable($statementForwardId, $message);

    }
    // pass in the query to prevent regeneration in the enable method
    return $this->enable($statementForwardId, $query);

  }

  public static function getSigner() {
    return new Sha256;
  }

  public static function getOrgIssuer($org) {
    return \Curatr\Helper::getSubdomainURL($org->alias);
filter:
    dependency_paths: ["lib/*"]
  }

  public static function getOrgSigningKey($org) {
    return $org->jwt_secret ?? 'default_key';
  }

  public function createSignedBearer() {
    $signer = self::getSigner();
    $issuer = self::getOrgIssuer($this->org);
    $token = (new Builder())->setIssuer($issuer) // Configures the issuer (iss claim)
                        ->setId($this->org->id, true) // Configures the id (jti claim), replicating as a header item
                        ->setIssuedAt(time()) // Configures the time that the token was issue (iat claim)
                        ->sign($signer, self::getOrgSigningKey($this->org))
                        ->getToken(); // Retrieves the generated token
    return $token->__toString();
  }

  private function title($message = "") {
    return trim($this->org->app_name . ' - ' . $this->org->name . ' - Object Completions ' . $message);
  }

  /**
   * Enable the Learning Locker Statement Forward.
   *
   * @param   $statementForwardId
   * @return  $response

   */
  public function enable($statementForwardId, $query = null) {
    $data = [
      "active" => true,
      "description" => $this->title(),
      "query" => $query ?: Query::statementForward($this->org->id),
      'configuration' => [
        'authType' => 'token',
        'secret' => $this->createSignedBearer()
      ]
    ];
    return $this->update($statementForwardId, $data);
  }

  /**
   * Disable the Learning Locker Statement Forward.
   *
   * @param   $id
   * @return  $response

   */
  public function disable($statementForwardId, $message) {
    $message = $message ?? '(Service Disabled)';
    $data = array(
      "active" => false,
      "description" => $this->title($message),
      "query" => json_encode(['$comment' => Query::COMMENT, 'disabled' => $message])
    );
    return $response = $this->update($statementForwardId, $data);

  }

  /**
   * Get the Learning Locker Statement Forward by ID.
   *
   * @param   $id
   * @return  $response

   */
  public function check($statementForwardId) {
    if (empty($statementForwardId)) return false;
    return $this->get($statementForwardId);
  }

  /**
   * Get the Learning Locker Statement Forward by ID.
   *
   * @param   $statementForwardId
   * @return  $response

   */
  public function get($statementForwardId) {
    try {
      $url = $this->endpoint . $this->api . $this->v2 . $this->statementForward . '/' . $statementForwardId;
      $request = $this->getClient()->get($url, [
        'auth' => $this->getAuth(),
        'headers' => [
          'content-type' => 'application/json'
        ],
      ]);

      if($request->getStatusCode() === 404) {
        throw new GuzzleHttp\Exception\ClientException('There was a issue connecting to Learning Locker.');
filter:
    dependency_paths: ["lib/*"]
      }
      return $request->json();
    } catch (Exception $e) {      
      if ($e instanceof \GuzzleHttp\Exception\ClientException) {
filter:
    dependency_paths: ["lib/*"]
        $responseBody = $e->getResponse()->getBody(true);
        $responseBody = $e->/** @scrutinizer ignore-call */ getResponse()->getBody(true);
        \Log::error('Error fetching statement forward', [
          'id' => $statementForwardId,
          'org_id'=>$this->org->id,
          'responseBody' => $responseBody
        ]);
      }
      return false;
    }
  }

  /**
   * Store the Learning Locker Statement Forward.
   *
   * @param   $data
   * @return  $response

   */ 
  public function store($data, $startEnabled = true) {
    $store = json_encode($data);
    try {
      $url = $this->endpoint . $this->api . $this->v2 . $this->statementForward;
      $request = $this->getClient()->post($url, array(
        'auth' => $this->getAuth(),
        'headers' => $this->headers,
        'body' => $store,
      ));
      $request = $request->json();
      if (isset($request['_id'])) {
        return $this->updateStatementForwardQuery($request['_id'], $startEnabled);
      }
      return false;
    } catch (Exception $e) {      
      if ($e instanceof \GuzzleHttp\Exception\ClientException) {
        $responseBody = $e->getResponse()->getBody(true);
        \Log::error('Error creating statement forward', [
          'data' => $data,
          'org_id'=>$this->org->id,
          'responseBody' => $responseBody
        ]);
      }
      return false;
    }
  }

  /**
   * Update the Learning Locker Statement Forward.
   *
   * @param   $statementForwardId, $data

   * @return  $response

   */
  protected function update($statementForwardId, $data) {
    if (empty($statementForwardId)) return false;
    $update = json_encode($data);
    try {
      $url = $this->endpoint . $this->api . $this->v2 . $this->statementForward . '/' . $statementForwardId;
      $request = $this->getClient()->patch($url, array(
        'auth' => $this->getAuth(), 
        'headers' => [
          'content-type' => 'application/json'
        ],
        'body' => $update,
      ));
      return $request->json();
    } catch (Exception $e) {      
      if ($e instanceof \GuzzleHttp\Exception\ClientException) {
        $responseBody = $e->getResponse()->getBody(true);
        \Log::error('Error updating statement forward', [
          'id' => $statementForwardId,
          'data' => $data,
          'org_id'=>$this->org->id,
          'responseBody' => $responseBody
        ]);
      }
      return false;
    }
  }

}

ijeffro / laralocker

StatementForward::updateStatementForwardQuery() A last analyzed 2019-11-28 14:53 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

StatementForward::updateStatementForwardQuery() A
last analyzed 2019-11-28 14:53 UTC
