POData\BaseService::serializeResult()

Complexity

Conditions	31
Paths	337

Size

Total Lines	164
Code Lines	92

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

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

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

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

        if (is_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_OK);

                return;
            }

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

            $targetResourceType = $request->getTargetResourceType();
            assert(null != $targetResourceType, 'Target resource type cannot be null');

            $method = (HTTPRequestMethod::POST() != $method);
            if (!$request->isSingleResult() && $method) {
                // Code path for collection (feed or links)
                $entryObjects = $request->getTargetResult();
                assert($entryObjects instanceof QueryResult, '!$entryObjects instanceof QueryResult');
                assert(is_array($entryObjects->results), '!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);
                    assert(
                        $odataModelInstance instanceof ODataURLCollection,
                        '!$odataModelInstance instanceof ODataURLCollection'
                    );
                } else {
                    $odataModelInstance = $objectModelSerializer->writeTopLevelElements($entryObjects);
                    assert($odataModelInstance instanceof ODataFeed, '!$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 (is_null($result->results)) {
                        throw ODataException::createResourceNotFoundError($request->getIdentifier());
                    }
                    $odataModelInstance = $objectModelSerializer->writeUrlElement($result);
                } elseif (TargetKind::RESOURCE() == $requestTargetKind
                          || TargetKind::SINGLETON() == $requestTargetKind) {
                    if (!is_null($this->getHost()->getRequestIfMatch())
                        && !is_null($this->getHost()->getRequestIfNoneMatch())
                    ) {
                        throw ODataException::createBadRequestError(
                            Messages::bothIfMatchAndIfNoneMatchHeaderSpecified()
                        );
                    }
                    // handle entry resource
                    $needToSerializeResponse = true;
                    $eTag = $this->compareETag($result, $targetResourceType, $needToSerializeResponse);

                    if ($needToSerializeResponse) {
                        if (is_null($result)) {
                            // 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'

38% of this comment could be valid code. Did you maybe forget this after debugging?

                        $this->getHost()->setResponseStatusCode(HttpStatus::CODE_NOT_MODIFIED);
                        $hasResponseBody = false;
                    }

                    // if resource has eTagProperty then eTag header needs to written
                    if (!is_null($eTag)) {
                        $this->getHost()->setResponseETag($eTag);
                    }
                } elseif (TargetKind::COMPLEX_OBJECT() == $requestTargetKind) {
                    assert(null != $requestProperty, 'Projected request property cannot be null');
                    $odataModelInstance = $objectModelSerializer->writeTopLevelComplexObject(
                        $result,
                        $requestProperty->getName(),
                        $targetResourceType
                    );
                } elseif (TargetKind::BAG() == $requestTargetKind) {
                    assert(null != $requestProperty, 'Projected request property cannot be null');
                    $odataModelInstance = $objectModelSerializer->writeTopLevelBagObject(
                        $result,
                        $requestProperty->getName(),
                        $targetResourceType,
                        $odataModelInstance

The call to IObjectSerialiser::writeTopLevelBagObject() has too many arguments starting with $odataModelInstance.

                    );
                } elseif (TargetKind::PRIMITIVE() == $requestTargetKind) {
                    $odataModelInstance = $objectModelSerializer->writeTopLevelPrimitive(
                        $result,
                        $requestProperty,
                        $odataModelInstance

The call to IObjectSerialiser::writeTopLevelPrimitive() has too many arguments starting with $odataModelInstance.

                    );
                } elseif (TargetKind::PRIMITIVE_VALUE() == $requestTargetKind) {

This elseif statement is empty, and could be removed.

                    // Code path for primitive value (Since its primitve no need for
                    // object model serialization)
                    // Customers('ANU')/CompanyName/$value => string

39% of this comment could be valid code. Did you maybe forget this after debugging?

                    // Employees(1)/Photo/$value => binary stream
                    // Customers/$count => string
                } else {
                    assert(false, 'Unexpected resource target kind');
                }
            }
        }

        //Note: Response content type can be null for named stream
        if ($hasResponseBody && !is_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);
        }
    }