POData\BaseService::serializeResult()

Complexity

Conditions	43
Paths	359

Size

Total Lines	177
Code Lines	99

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
    protected function serializeResult(RequestDescription $request, IUriProcessor $uriProcessor)
    {
        $isETagHeaderAllowed = $request->isETagHeaderAllowed();

        if ($this->getConfiguration()->getValidateETagHeader() && !$isETagHeaderAllowed) {
            if (null !== $this->getHost()->getRequestIfMatch()
                || null !== $this->getHost()->getRequestIfNoneMatch()
            ) {
                throw ODataException::createBadRequestError(
                    Messages::eTagCannotBeSpecified($this->getHost()->getAbsoluteRequestUri()->getUrlAsString())
                );
            }
        }

        $responseContentType = $this->getResponseContentType($request, $uriProcessor);

        if (null === $responseContentType && $request->getTargetKind() != TargetKind::MEDIA_RESOURCE()) {
            //the responseContentType can ONLY be null if it's a stream (media resource) and
            // that stream is storing null as the content type
            throw new ODataException(Messages::unsupportedMediaType(), 415);
        }

        $odataModelInstance = null;
        $hasResponseBody    = true;
        // Execution required at this point if request points to any resource other than

        // (1) media resource - For Media resource 'getResponseContentType' already performed execution as
        // it needs to know the mime type of the stream
        // (2) metadata - internal resource
        // (3) service directory - internal resource
        if ($request->needExecution()) {
            $method = $this->getHost()->getOperationContext()->incomingRequest()->getMethod();
            $uriProcessor->execute();
            if (HTTPRequestMethod::DELETE() == $method) {
                $this->getHost()->setResponseStatusCode(HttpStatus::CODE_NOCONTENT);

                return;
            }

            $objectModelSerializer = $this->getObjectSerialiser();
            $objectModelSerializer->setRequest($request);

            $targetResourceType = $request->getTargetResourceType();
            if (null === $targetResourceType) {
                throw new InvalidOperationException('Target resource type cannot be null');
            }

            $methodIsNotPost   = (HTTPRequestMethod::POST() != $method);
            $methodIsNotDelete = (HTTPRequestMethod::DELETE() != $method);
            if (!$request->isSingleResult() && $methodIsNotPost) {
                // Code path for collection (feed or links)
                $entryObjects = $request->getTargetResult();
                if (!$entryObjects instanceof QueryResult) {
                    throw new InvalidOperationException('!$entryObjects instanceof QueryResult');
                }
                if (!is_array($entryObjects->results)) {
                    throw new InvalidOperationException('!is_array($entryObjects->results)');
                }
                // If related resource set is empty for an entry then we should
                // not throw error instead response must be empty feed or empty links
                if ($request->isLinkUri()) {
                    $odataModelInstance = $objectModelSerializer->writeUrlElements($entryObjects);
                    if (!$odataModelInstance instanceof ODataURLCollection) {

$odataModelInstance is always a sub-type of POData\ObjectModel\ODataURLCollection.

                        throw new InvalidOperationException('!$odataModelInstance instanceof ODataURLCollection');
                    }
                } else {
                    $odataModelInstance = $objectModelSerializer->writeTopLevelElements($entryObjects);
                    if (!$odataModelInstance instanceof ODataFeed) {

$odataModelInstance is always a sub-type of POData\ObjectModel\ODataFeed.

                        throw new InvalidOperationException('!$odataModelInstance instanceof ODataFeed');
                    }
                }
            } else {
                // Code path for entity, complex, bag, resource reference link,
                // primitive type or primitive value
                $result = $request->getTargetResult();
                if (!$result instanceof QueryResult) {
                    $result          = new QueryResult();
                    $result->results = $request->getTargetResult();
                }
                $requestTargetKind = $request->getTargetKind();
                $requestProperty   = $request->getProjectedProperty();
                if ($request->isLinkUri()) {
                    // In the query 'Orders(1245)/$links/Customer', the targeted
                    // Customer might be null
                    if (null === $result->results && $methodIsNotPost && $methodIsNotDelete) {
                        throw ODataException::createResourceNotFoundError($request->getIdentifier());
                    }
                    if ($methodIsNotPost && $methodIsNotDelete) {
                        $odataModelInstance = $objectModelSerializer->writeUrlElement($result);
                    }
                } elseif (TargetKind::RESOURCE() == $requestTargetKind
                    || TargetKind::SINGLETON() == $requestTargetKind) {
                    if (null !== $this->getHost()->getRequestIfMatch()
                        && null !== $this->getHost()->getRequestIfNoneMatch()
                    ) {
                        throw ODataException::createBadRequestError(
                            Messages::bothIfMatchAndIfNoneMatchHeaderSpecified()
                        );
                    }
                    // handle entry resource
                    $needToSerializeResponse = true;
                    $eTag                    = $this->compareETag(
                        $result,
                        $targetResourceType,
                        $needToSerializeResponse
                    );
                    if ($needToSerializeResponse) {
                        if (null === $result || null === $result->results) {
                            // In the query 'Orders(1245)/Customer', the targeted
                            // Customer might be null
                            // set status code to 204 => 'No Content'
                            $this->getHost()->setResponseStatusCode(HttpStatus::CODE_NOCONTENT);
                            $hasResponseBody = false;
                        } else {
                            $odataModelInstance = $objectModelSerializer->writeTopLevelElement($result);
                        }
                    } else {
                        // Resource is not modified so set status code
                        // to 304 => 'Not Modified'
                        $this->getHost()->setResponseStatusCode(HttpStatus::CODE_NOT_MODIFIED);
                        $hasResponseBody = false;
                    }

                    // if resource has eTagProperty then eTag header needs to written
                    if (null !== $eTag) {
                        $this->getHost()->setResponseETag($eTag);
                    }
                } elseif (TargetKind::COMPLEX_OBJECT() == $requestTargetKind) {
                    if (null === $requestProperty) {
                        throw new InvalidOperationException('Projected request property cannot be null');
                    }
                    $odataModelInstance = $objectModelSerializer->writeTopLevelComplexObject(
                        $result,
                        $requestProperty->getName(),
                        $targetResourceType
                    );
                } elseif (TargetKind::BAG() == $requestTargetKind) {
                    if (null === $requestProperty) {
                        throw new InvalidOperationException('Projected request property cannot be null');
                    }
                    $odataModelInstance = $objectModelSerializer->writeTopLevelBagObject(
                        $result,
                        $requestProperty->getName(),
                        $targetResourceType
                    );
                } elseif (TargetKind::PRIMITIVE() == $requestTargetKind) {
                    $odataModelInstance = $objectModelSerializer->writeTopLevelPrimitive(
                        $result,
                        $requestProperty
                    );
                } elseif (TargetKind::PRIMITIVE_VALUE() == $requestTargetKind) {
                    // Code path for primitive value (Since its primitive no need for
                    // object model serialization)
                    // Customers('ANU')/CompanyName/$value => string
                    // Employees(1)/Photo/$value => binary stream
                    // Customers/$count => string
                } else {
                    throw new InvalidOperationException('Unexpected resource target kind');
                }
            }
        }

        //Note: Response content type can be null for named stream
        if ($hasResponseBody && null !== $responseContentType) {
            if (TargetKind::MEDIA_RESOURCE() != $request->getTargetKind()
                && MimeTypes::MIME_APPLICATION_OCTETSTREAM != $responseContentType) {
                //append charset for everything except:
                //stream resources as they have their own content type
                //binary properties (they content type will be App Octet for those...is this a good way?
                //we could also decide based upon the projected property

                $responseContentType .= ';charset=utf-8';
            }
        }

        if ($hasResponseBody) {
            ResponseWriter::write($this, $request, $odataModelInstance, $responseContentType);
        }