EventEspresso\core\domain\services\graphql\resolvers\FieldResolver

Complexity

Total Complexity

27

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	resolve()	0	39	11
A	resolveWpUser()	0	7	2
A	resolveParent()	0	4	1
A	resolveEvent()	0	18	5
A	resolveState()	0	16	3
A	resolveCountry()	0	19	4

<?php

namespace EventEspresso\core\domain\services\graphql\resolvers;

use EEM_Base;
use EE_Base_Class;
use EE_Event;
use EE_Venue;
use EE_Datetime;
use EE_Ticket;
use EE_State;
use EEM_State;
use EE_Country;
use EEM_Country;
use EE_Error;

use EventEspresso\core\exceptions\InvalidDataTypeException;
use EventEspresso\core\exceptions\InvalidInterfaceException;
use EventEspresso\core\services\graphql\TypeBase;
use EventEspresso\core\services\graphql\ResolverBase;
use EventEspresso\core\domain\services\graphql\fields\GraphQLField;
use InvalidArgumentException;
use ReflectionException;

use WPGraphQL\Data\DataSource;
use GraphQL\Deferred;
use GraphQL\Error\UserError;
use WPGraphQL\Model\Post;
use GraphQL\Type\Definition\ResolveInfo;
use WPGraphQL\AppContext;


/**
 * Class FieldResolver
 * Field resolver for a GraphQL type
 *
 * @package EventEspresso\core\domain\services\graphql\resolvers
 * @author  Manzoor Wani
 * @since   $VID:$
 */
class FieldResolver extends ResolverBase
{

    /**
     * @var mixed $model
     */
    protected $model;

    /**
     * @var array $fields.
     */
    protected $fields;


    /**
     * FieldResolver constructor.
     *
	 * @param mixed   $model  The model instance.
     * @param array   $fields The fields registered for the type.
     */
    public function __construct($model, array $fields )
    {
		$this->model  = $model;
		$this->fields = $fields;
    }

    /**
     * @param mixed       $source     The source that's passed down the GraphQL queries
     * @param array       $args       The inputArgs on the field
     * @param AppContext  $context    The AppContext passed down the GraphQL tree
     * @param ResolveInfo $info       The ResolveInfo passed down the GraphQL tree
     * @return string
     * @since $VID:$
     */
    public function resolve($source, $args, AppContext $context, ResolveInfo $info)
    {
        $fieldName = $info->fieldName;
        
        // Field should exist in teh registered fields
		if (isset($this->fields[$fieldName]) && $this->fields[$fieldName] instanceof GraphQLField) {
            $field = $this->fields[$fieldName];

            // check if the field should be resolved.
            if (!$field->shouldResolve()) {
                return null;
            }

            // Give priority to the internal resolver.
            if ($field->hasInternalResolver()) {
                return call_user_func($field->resolve, $source, $args, $context, $info);
            }

            // Check if the field has a key mapped to model.
            if (!empty($field->key())) {
                $value = $source->{$field->key()}();
                return $field->mayBeFormatValue($value);
            }

            switch ($fieldName) {
                case 'parent':
                    return $this->resolveParent($source);
                case 'event':
                    return $this->resolveEvent($source, $args, $context);
                case 'wpUser':
                    return $this->resolveWpUser($source, $args, $context);
                case 'state': // Venue
                    return $this->resolveState($source);
                case 'country': // State, Venue
                    return $this->resolveCountry($source);
            }
        }
        return null;
    }


    /**
     * @param mixed     $source
     * @param           $args
     * @param           $context
     * @return Deferred|null
     * @throws EE_Error
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws ReflectionException
     * @throws UserError
     * @since $VID:$
     */
    public function resolveWpUser($source, $args, $context)
    {
        $user_id = $source->wp_user();
        return $user_id
            ? DataSource::resolve_user($user_id, $context)
            : null;
    }


    /**
     * @param mixed $source
     * @return EE_Base_Class|null
     * @throws EE_Error
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws ReflectionException
     * @since $VID:$
     */
    public function resolveParent($source)
    {
        return $this->model->get_one_by_ID($source->parent());
    }


    /**
     * @param mixed       $source
     * @param             $args
     * @param             $context
     * @return Deferred|null
     * @throws EE_Error
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws UserError
     * @throws InvalidArgumentException
     * @throws ReflectionException
     * @since $VID:$
     */
    public function resolveEvent($source, $args, $context)
    {
        switch (true) {
            case $source instanceof EE_Datetime:
                $event = $source->event();
                break;
            case $source instanceof EE_Venue:
            case $source instanceof EE_Ticket:
                $event = $source->get_related_event();

The method get_related_event does only exist in EE_Ticket, but not in EE_Venue.

                break;
            default:
                $event = null;
                break;
        }
        return $event instanceof EE_Event
            ? DataSource::resolve_post_object($event->ID(), $context)
            : null;
    }


    /**
     * @param mixed $source The source instance.
     * @return int
     * @since $VID:$
     */
    public function resolveState($source)
    {
        switch (true) {
            case $source instanceof EE_Venue:
                $state_id = $source->state_ID();
                break;
            default:
                $state_id = null;
                break;
        }

        if ($state_id) {

The expression $state_id of type integer|null is loosely compared to true; this is ambiguous if the integer can be zero. You might want to explicitly use !== null instead.

            return EEM_State::instance()->get_one_by_ID($state_id);
        }
        return null;
    }


    /**
     * @param mixed $source The source instance.
     * @return int
     * @since $VID:$
     */
    public function resolveCountry($source)
    {
        switch (true) {
            case $source instanceof EE_State:
                $country_iso = $source->country_iso();
                break;
            case $source instanceof EE_Venue:
                $country_iso = $source->country_ID();
                break;
            default:
                $country_iso = null;
                break;
        }

        if ($country_iso) {

The expression $country_iso of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            return EEM_Country::instance()->get_one_by_ID($country_iso);
        }
        return null;
    }
}