Handling file uploads about lighthouse HOT 13 CLOSED

namespace App\Interactions\Traits;

trait RelayCreateHandler
{
    public $isRelay = false;
    public $responseMsg = '';

    public function relayValidator(array $data)
    {
        $payload = array_get($data, 'payload');

        if (!$payload) {
            throw new ValidationError('Form should be wrapped in a payload.');
        }

        return $this->validator($payload);
    }

    public function relayHandle(array $data)
    {
        $this->isRelay = true;

        return $this->handle(array_get($data, 'payload'));
    }

    public function relayResponse($payload = [], $success = true)
    {
        return [
            'success' => $success,
            'msg' => $this->responseMsg,
            'payload' => json_encode($payload),
        ];
    }
}

namespace App\Interactions\Traits;

trait RelayUpdateHandler
{
    protected $isRelay = false;
    protected $responseMsg = '';

    public function relayValidator(array $data)
    {
        $payload = array_get($data, 'payload');

        if (!$payload) {

            throw new ValidationError('Form should be wrapped in a payload.');
        }

        return $this->validator(auth()->id(), $payload);
    }

    public function relayHandle(array $data)
    {
        $this->isRelay = true;

        return $this->handle(auth()->id(), array_get($data, 'payload'));
    }

    public function relayResponse($success = true, $payload = [])
    {
        return [
            'success' => $success,
            'msg' => $this->responseMsg,
            'payload' => json_encode($payload),
        ];
    }
}

namespace App\GraphQL\Directives;

use GraphQL\Language\AST\DirectiveNode;
use Nuwave\Lighthouse\Schema\Values\FieldValue;
use Nuwave\Lighthouse\Support\Contracts\FieldResolver;
use Nuwave\Lighthouse\Support\Exceptions\DirectiveException;
use Nuwave\Lighthouse\Support\Exceptions\ValidationError;
use Nuwave\Lighthouse\Support\Traits\HandlesDirectives;

class InteractionDirective implements FieldResolver
{
    use HandlesDirectives;

    /**
     * Name of the directive.
     *
     * @return string
     */
    public function name()
    {
        return 'interaction';
    }

    /**
     * Resolve the field directive.
     *
     * @param FieldValue $value
     *
     * @return FieldValue
     */
    public function resolveField(FieldValue $value)
    {
        $directive = $this->fieldDirective($value->getField(), $this->name());
        $className = $this->getClassName($directive);
        $data = $this->argValue(collect($directive->arguments)->first(function ($arg) {
            return 'args' === data_get($arg, 'name.value');
        }));

        return $value->setResolver(function ($root, array $args, $context = null, $info = null) use ($className, $data) {

            return $this->interaction($className, [$args]);
        });
    }

    /**
     * Get class name for resolver.
     *
     * @param DirectiveNode $directive
     *
     * @return string
     */
    protected function getClassName(DirectiveNode $directive)
    {
        $class = $this->directiveArgValue($directive, 'class');

        if (!$class) {
            throw new DirectiveException(sprintf(
                'Directive [%s] must have a `class` argument.',
                $directive->name->value
            ));
        }

        return $class;
    }

    protected function interaction($interaction, array $parameters)
    {
        $validator = $this->call($interaction . '@relayValidator', $parameters);

        if ($validator->fails()) {
            throw with(new ValidationError('validation'))->setValidator($validator);
        }

        return $this->call($interaction, $parameters);
    }

    /**
     * Will call interacion handle function if no other method its defined.
     *
     * @param  string $interaction
     * @param  array  $parameters
     * @return mixed
     */
    protected function call($interaction, array $parameters = [])
    {
        if (!str_contains($interaction, '@')) {
            $interaction = $interaction . '@relayHandle';
        }

        list($class, $method) = explode('@', $interaction);

        $base = class_basename($class);

        return call_user_func_array([app($class), $method], $parameters);
    }

}

namespace App\Interactions;

use App\Enums\GalleryType;
use App\Repositories\GalleryRepository;
use Illuminate\Support\Facades\Validator;
use Nuwave\Lighthouse\Support\Exceptions\ValidationError;

class UserMediaContribution
{
    use RelayUpdateHandler;

    public function validator($id, array $data)
    {
        return Validator::make($data, [
            'title' => 'required|string|min:5|max:255',
            'body' => 'nullable|string|min:5|max:255',
        ]);
    }

    public function handle($id, array $data)
    {
        if (request()->hasFile('file')) {

            $contribGallery = Larapp::call(GalleryRepository::class . '@contribGalleryForApp', []);

            $name = array_get($data, 'title');
            $body = array_get($data, 'body');

            $contribGallery->addMediaFromRequest('file')
                ->usingName($name)
                ->withCustomProperties(['pass' => 'n', 'body' => $body, 'by' => $id])
                ->toMediaCollection(GalleryType::GA_CONTRIBUTIONS);

            if ($this->isRelay) {
                $this->responseMsg = 'La foto se ha recibido satisfactoriamente, será publicada despues de haberse aprobado.';

                return $this->relayResponse($data);
            }

            return $data;

        } else {

            throw new ValidationError('No Photo found in request, contact admin.');
        }

    }

}