Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
79.44%
85 / 107
63.64%
7 / 11
 CRAP
0.00%
0 / 1
RunItemMethodAction
79.44%
85 / 107
63.64%
7 / 11
 59.07
0.00%
0 / 1
 __construct
100.00%
1 / 1
100.00%
1 / 1
 1
 isAuthorized
56.25%
9 / 16
0.00%
0 / 1
 18.37
 __invoke
69.05%
29 / 42
0.00%
0 / 1
 9.90
 shouldReturnResource
100.00%
6 / 6
100.00%
1 / 1
 5
 getDisplayNameForMethod
87.50%
7 / 8
0.00%
0 / 1
 6.07
 getInputType
100.00%
2 / 2
100.00%
1 / 1
 1
 getOutputType
100.00%
4 / 4
100.00%
1 / 1
 2
 getPossibleActionResponseStatuses
100.00%
7 / 7
100.00%
1 / 1
 3
 getDescription
100.00%
7 / 7
100.00%
1 / 1
 3
 getTags
80.00%
4 / 5
0.00%
0 / 1
 3.07
 getRouteAttributes
100.00%
9 / 9
100.00%
1 / 1
 1
1<?php
2namespace Apie\Common\Actions;
3
4use Apie\Common\IntegrationTestLogger;
5use Apie\Core\Actions\ActionResponse;
6use Apie\Core\Actions\ActionResponseStatus;
7use Apie\Core\Actions\ActionResponseStatusList;
8use Apie\Core\Actions\ApieFacadeInterface;
9use Apie\Core\Actions\MethodActionInterface;
10use Apie\Core\BoundedContext\BoundedContextId;
11use Apie\Core\Context\ApieContext;
12use Apie\Core\ContextConstants;
13use Apie\Core\Entities\EntityInterface;
14use Apie\Core\Exceptions\EntityNotFoundException;
15use Apie\Core\Exceptions\InvalidTypeException;
16use Apie\Core\IdentifierUtils;
17use Apie\Core\Lists\StringList;
18use Apie\Core\TypeUtils;
19use Apie\Core\Utils\EntityUtils;
20use Apie\Core\ValueObjects\Exceptions\InvalidStringForValueObjectException;
21use Apie\Serializer\Exceptions\ValidationException;
22use Exception;
23use LogicException;
24use ReflectionClass;
25use ReflectionException;
26use ReflectionMethod;
27use ReflectionNamedType;
28
29/**
30 * Runs a method from  a resource (and persist resource afterwards).
31 */
32final class RunItemMethodAction implements MethodActionInterface
33{
34    public function __construct(private readonly ApieFacadeInterface $apieFacade)
35    {
36    }
37
38    public static function isAuthorized(ApieContext $context, bool $runtimeChecks, bool $throwError = false): bool
39    {
40        $refl = new ReflectionClass($context->getContext(ContextConstants::RESOURCE_NAME, $throwError));
41        $methodName = $context->getContext(ContextConstants::METHOD_NAME, $throwError);
42        $method = new ReflectionMethod(
43            $context->getContext(ContextConstants::METHOD_CLASS, $throwError),
44            $methodName
45        );
46        if (EntityUtils::isPolymorphicEntity($refl) && $runtimeChecks && $context->hasContext(ContextConstants::RESOURCE) &&!$method->isStatic()) {
47            $refl = new ReflectionClass($context->getContext(ContextConstants::RESOURCE, $throwError));
48            if (!$refl->hasMethod($methodName)) {
49                if ($throwError) {
50                    throw new LogicException('Method ' . $methodName . ' does not exist on this entity');
51                }
52                return false;
53            }
54            $method = $refl->getMethod($methodName);
55        }
56        if (!$context->appliesToContext($refl, $runtimeChecks, $throwError ? new LogicException('Class access is not allowed!') : null)) {
57            return false;
58        }
59        return $context->appliesToContext($method, $runtimeChecks, $throwError ? new LogicException('Class method is not allowed') : null);
60    }
61
62    /**
63     * @param array<string|int, mixed> $rawContents
64     */
65    public function __invoke(ApieContext $context, array $rawContents): ActionResponse
66    {
67        $context->withContext(ContextConstants::APIE_ACTION, __CLASS__)->checkAuthorization();
68        $resourceClass = new ReflectionClass($context->getContext(ContextConstants::RESOURCE_NAME));
69        if (!$resourceClass->implementsInterface(EntityInterface::class)) {
70            throw new InvalidTypeException($resourceClass->name, 'EntityInterface');
71        }
72        $method = new ReflectionMethod(
73            $context->getContext(ContextConstants::METHOD_CLASS),
74            $context->getContext(ContextConstants::METHOD_NAME)
75        );
76        if ($method->isStatic()) {
77            $resource = null;
78        } else {
79            $id = $context->getContext(ContextConstants::RESOURCE_ID);
80            try {
81                $resource = $this->apieFacade->find(
82                    IdentifierUtils::idStringToIdentifier($id, $context),
83                    new BoundedContextId($context->getContext(ContextConstants::BOUNDED_CONTEXT_ID))
84                );
85            } catch (InvalidStringForValueObjectException|EntityNotFoundException $error) {
86                IntegrationTestLogger::logException($error);
87                return ActionResponse::createClientError($this->apieFacade, $context, $error);
88            }
89            $context = $context->withContext(ContextConstants::RESOURCE, $resource);
90            // polymorphic relation, so could be the incorrect declared method
91            if (!$method->getDeclaringClass()->isInstance($resource)) {
92                try {
93                    $method = (new ReflectionClass($resource))->getMethod($method->name);
94                } catch (ReflectionException $methodError) {
95                    $error = new Exception(
96                        sprintf('Resource "%s" does not support "%s"!', $id, $method->name),
97                        0,
98                        $methodError
99                    );
100                    throw ValidationException::createFromArray(['' => $error]);
101                }
102            }
103        }
104
105        $result = $this->apieFacade->denormalizeOnMethodCall(
106            $rawContents,
107            $resource,
108            $method,
109            $context
110        );
111        if ($resource !== null) {
112            $resource = $this->apieFacade->persistExisting(
113                $resource,
114                new BoundedContextId($context->getContext(ContextConstants::BOUNDED_CONTEXT_ID))
115            );
116        }
117        if (self::shouldReturnResource($method)) {
118            $result = $resource;
119        }
120        return ActionResponse::createRunSuccess($this->apieFacade, $context, $result, $resource);
121    }
122
123    /**
124     * Returns true if we should not return the return value of the method, but should return the return value of the resource.
125     * This is the case if:
126     * - The method returns void
127     * - The method call starts with 'add' or 'remove' and has arguments.
128     */
129    public static function shouldReturnResource(ReflectionMethod $method): bool
130    {
131        $returnType = $method->getReturnType();
132        if ($returnType instanceof ReflectionNamedType && 'void' === $returnType->getName()) {
133            return true;
134        }
135        if ($method->getNumberOfParameters() === 0) {
136            return false;
137        }
138                
139        return str_starts_with($method->name, 'add') || str_starts_with($method->name, 'remove');
140    }
141
142    /**
143     * Returns a string how we should display the method. For example we remove 'add' or 'remove' from the string.
144     */
145    public static function getDisplayNameForMethod(ReflectionMethod $method): string
146    {
147        if ($method->getNumberOfParameters() > 0) {
148            if (str_starts_with($method->name, 'remove')) {
149                return lcfirst(substr($method->name, strlen('remove')));
150            }
151            if (str_starts_with($method->name, 'add')) {
152                return lcfirst(substr($method->name, strlen('add')));
153            }
154        }
155        if (str_starts_with($method->name, 'get') && TypeUtils::couldBeAStream($method->getReturnType())) {
156            return lcfirst(substr($method->name, strlen('get')));
157        }
158        return $method->name;
159    }
160
161    /** @param ReflectionClass<object> $class */
162    public static function getInputType(ReflectionClass $class, ?ReflectionMethod $method = null): ReflectionMethod
163    {
164        assert($method instanceof ReflectionMethod);
165        return $method;
166    }
167
168    /** @param ReflectionClass<object> $class */
169    public static function getOutputType(ReflectionClass $class, ?ReflectionMethod $method = null): ReflectionMethod|ReflectionClass
170    {
171        assert($method instanceof ReflectionMethod);
172        if (RunItemMethodAction::shouldReturnResource($method)) {
173            return $class;
174        }
175        return $method;
176    }
177
178    public static function getPossibleActionResponseStatuses(?ReflectionMethod $method = null): ActionResponseStatusList
179    {
180        assert($method instanceof ReflectionMethod);
181        $list = [ActionResponseStatus::SUCCESS];
182
183        if (!empty($method->getParameters())) {
184            $list[] = ActionResponseStatus::CLIENT_ERROR;
185        }
186        if (!$method->isStatic()) {
187            $list[] = ActionResponseStatus::NOT_FOUND;
188        }
189        return new ActionResponseStatusList($list);
190    }
191
192    /**
193     * @param ReflectionClass<object> $class
194     */
195    public static function getDescription(ReflectionClass $class, ?ReflectionMethod $method = null): string
196    {
197        assert($method instanceof ReflectionMethod);
198        $name = self::getDisplayNameForMethod($method);
199        if (str_starts_with($method->name, 'add')) {
200            return 'Adds ' . $name . ' to ' . $class->getShortName();
201        }
202        if (str_starts_with($method->name, 'remove')) {
203            return 'Removes ' . $name . ' from ' . $class->getShortName();
204        }
205        return 'Runs method ' . $name . ' on a ' . $class->getShortName() . ' with a specific id';
206    }
207    
208    /**
209     * @param ReflectionClass<object> $class
210     */
211    public static function getTags(ReflectionClass $class, ?ReflectionMethod $method = null): StringList
212    {
213        $className = $class->getShortName();
214        $declared = $method ? $method->getDeclaringClass()->getShortName() : $className;
215        if ($className !== $declared) {
216            return new StringList([$className, $declared, 'action']);
217        }
218        return new StringList([$className, 'action']);
219    }
220
221    /**
222     * @param ReflectionClass<object> $class
223     */
224    public static function getRouteAttributes(ReflectionClass $class, ?ReflectionMethod $method = null): array
225    {
226        return
227        [
228            ContextConstants::GET_OBJECT => true,
229            ContextConstants::RESOURCE_METHOD => true,
230            ContextConstants::RESOURCE_NAME => $class->name,
231            ContextConstants::METHOD_CLASS => $method->getDeclaringClass()->name,
232            ContextConstants::METHOD_NAME => $method->name,
233            ContextConstants::DISPLAY_FORM => true,
234        ];
235    }
236}