#4053

Committed 10 Feb 2025 01:14PM CUT coverage: 35.271% (-0.02%) from 35.294%

Build # #4053

Build Type

push

github

Committed by

topframe

Commit Message

Update

Run Details

0 of 1 new or added line in 1 file covered. (0.0%)

155 existing lines in 3 files now uncovered.

14245 of 40387 relevant lines covered (35.27%)

0.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/web/src/main/java/com/aspectran/web/activity/response/DefaultRestResponse.java

/*
 * Copyright (c) 2008-2025 The Aspectran Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.aspectran.web.activity.response;

import com.aspectran.core.activity.Activity;
import com.aspectran.core.activity.response.transform.AponTransformResponse;
import com.aspectran.core.activity.response.transform.JsonTransformResponse;
import com.aspectran.core.activity.response.transform.XmlTransformResponse;
import com.aspectran.core.adapter.RequestAdapter;
import com.aspectran.core.adapter.ResponseAdapter;
import com.aspectran.utils.Assert;
import com.aspectran.utils.StringifyContext;
import com.aspectran.utils.ToStringBuilder;
import com.aspectran.utils.annotation.jsr305.NonNull;
import com.aspectran.utils.apon.ObjectToParameters;
import com.aspectran.utils.apon.Parameters;
import com.aspectran.utils.json.JsonWriter;
import com.aspectran.web.support.http.HttpMediaTypeNotAcceptableException;
import com.aspectran.web.support.http.HttpStatus;
import com.aspectran.web.support.http.MediaType;

import javax.xml.transform.TransformerException;
import java.io.IOException;
import java.io.Writer;
import java.nio.charset.Charset;
import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * The default RestResponse supports APON, JSON, and XML data types.
 *
 * <p>Created: 2019-06-16</p>
 */
public class DefaultRestResponse extends AbstractRestResponse {

    private static final int MAX_INDENT = 8;

    private static final List<MediaType> supportedContentTypes;
    static {
        supportedContentTypes = List.of(
                MediaType.TEXT_PLAIN,
                MediaType.TEXT_HTML,
                MediaType.APPLICATION_JSON,
                MediaType.APPLICATION_APON,
                MediaType.APPLICATION_XML);
    }

    private static final Map<String, MediaType> supportedPathExtensions;
    static {
        supportedPathExtensions = Map.of(
                "json", MediaType.APPLICATION_JSON,
                "apon", MediaType.APPLICATION_APON,
                "xml", MediaType.APPLICATION_XML,
                "txt", MediaType.TEXT_PLAIN,
                "html", MediaType.TEXT_HTML,
                "htm", MediaType.TEXT_HTML);
    }

    public DefaultRestResponse() {
        super();
    }

    public DefaultRestResponse(Object data) {
        super(data);
    }

    public DefaultRestResponse(String label, Object data) {
        super(label, data);
    }

    @Override
    protected List<MediaType> getSupportedContentTypes() {
        return supportedContentTypes;
    }

    @Override
    protected MediaType getContentTypeByPathExtension(String extension) {
        return supportedPathExtensions.get(extension);
    }

    @Override
    public void transform(Activity activity) throws Exception {
        Assert.notNull(activity, "activity must not be null");
        ResponseAdapter responseAdapter = activity.getResponseAdapter();

        MediaType acceptContentType;
        try {
            acceptContentType = determineAcceptContentType(activity);
        } catch (HttpMediaTypeNotAcceptableException e) {
            responseAdapter.setStatus(HttpStatus.NOT_ACCEPTABLE.value());
            return;
        }

        MediaType responseContentType = determineResponseContentType(activity, acceptContentType);
        responseAdapter.setContentType(responseContentType.toString());

        transformByContentType(activity, acceptContentType);

        if (getHeaders() != null) {
            for (Map.Entry<String, List<String>> entry : getHeaders().entrySet()) {
                String name = entry.getKey();
                List<String> values = entry.getValue();
                for (String value : values) {
                    responseAdapter.addHeader(name, value);
                }
            }
        }

        if (getStatus() > 0) {
            responseAdapter.setStatus(getStatus());
        }
    }

    protected void transformByContentType(Activity activity, MediaType contentType) throws Exception {
        if (MediaType.APPLICATION_JSON.equalsTypeAndSubtype(contentType)) {
            toJSON(activity, parseIndent(contentType));
        } else if (MediaType.APPLICATION_APON.equalsTypeAndSubtype(contentType)) {
            toAPON(activity, parseIndent(contentType));
        } else if (MediaType.APPLICATION_XML.equalsTypeAndSubtype(contentType)) {
            Charset charset = contentType.getCharset();
            String encoding = (charset != null ? charset.name() : null);
            toXML(activity, encoding, parseIndent(contentType));
        } else {
            toText(activity);
        }
    }

    private void toJSON(@NonNull Activity activity, int indent) throws IOException {
        RequestAdapter requestAdapter = activity.getRequestAdapter();
        ResponseAdapter responseAdapter = activity.getResponseAdapter();
        Writer writer = responseAdapter.getWriter();

        // support for jsonp
        String callback = requestAdapter.getParameter(JsonTransformResponse.CALLBACK_PARAM_NAME);
        if (callback != null) {
            writer.write(callback + JsonTransformResponse.ROUND_BRACKET_OPEN);
        }
        if (getName() != null || getData() != null) {
            StringifyContext stringifyContext = resolveStringifyContext(activity, indent);
            JsonWriter jsonWriter = new JsonWriter(writer);
            jsonWriter.setStringifyContext(stringifyContext);
            if (getName() != null) {
                jsonWriter.beginObject();
                jsonWriter.writeName(getName());
            }
            jsonWriter.writeValue(getData());
            if (getName() != null) {
                jsonWriter.endObject();
            }
        }
        if (callback != null) {
            writer.write(JsonTransformResponse.ROUND_BRACKET_CLOSE);
        }
    }

    private void toAPON(Activity activity, int indent) throws IOException {
        if (getName() != null || getData() != null) {
            ResponseAdapter responseAdapter = activity.getResponseAdapter();
            Writer writer = responseAdapter.getWriter();
            StringifyContext stringifyContext = resolveStringifyContext(activity, indent);

            Parameters parameters;
            if (getName() != null) {
                parameters = ObjectToParameters.from(getName(), getData(), stringifyContext);
            } else {
                parameters = ObjectToParameters.from(getData(), stringifyContext);
            }

            AponTransformResponse.transform(parameters, writer, stringifyContext);
        }
    }

    private void toXML(Activity activity, String encoding, int indent) throws IOException, TransformerException {
        if (getName() != null || getData() != null) {
            ResponseAdapter responseAdapter = activity.getResponseAdapter();
            Writer writer = responseAdapter.getWriter();
            StringifyContext stringifyContext = resolveStringifyContext(activity, indent);

            Object data;
            if (getName() != null) {
                data = Collections.singletonMap(getName(), getData());
            } else {
                data = getData();
            }
            XmlTransformResponse.transform(data, writer, encoding, stringifyContext);
        }
    }

    private void toText(Activity activity) throws IOException {
        if (getName() != null || getData() != null) {
            ResponseAdapter responseAdapter = activity.getResponseAdapter();
            Writer writer = responseAdapter.getWriter();
            if (getData() != null) {
                writer.write(ToStringBuilder.toString(getName(), getData()));
            }
        }
    }

    @NonNull
    private StringifyContext resolveStringifyContext(@NonNull Activity activity, int indent) {
        StringifyContext stringifyContext = getStringifyContext();
        if (stringifyContext == null) {
            stringifyContext = activity.getStringifyContext().clone();
        } else {
            stringifyContext.merge(activity.getStringifyContext());
        }
        if (stringifyContext.isPretty() && !stringifyContext.hasIndentSize() && indent > -1) {
            stringifyContext.setIndentSize(indent);
        }
        return stringifyContext;
    }

    private int parseIndent(@NonNull MediaType contentType) {
        try {
            String indent = contentType.getParameter("indent");
            if (indent != null) {
                int depth = Integer.parseInt(indent);
                return (Math.min(depth, MAX_INDENT));
            }
        } catch (NumberFormatException e) {
            // ignored
        }
        return -1;
    }

}

1	/*
2	* Copyright (c) 2008-2025 The Aspectran Project
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package com.aspectran.web.activity.response;
17
18	import com.aspectran.core.activity.Activity;
19	import com.aspectran.core.activity.response.transform.AponTransformResponse;
20	import com.aspectran.core.activity.response.transform.JsonTransformResponse;
21	import com.aspectran.core.activity.response.transform.XmlTransformResponse;
22	import com.aspectran.core.adapter.RequestAdapter;
23	import com.aspectran.core.adapter.ResponseAdapter;
24	import com.aspectran.utils.Assert;
25	import com.aspectran.utils.StringifyContext;
26	import com.aspectran.utils.ToStringBuilder;
27	import com.aspectran.utils.annotation.jsr305.NonNull;
28	import com.aspectran.utils.apon.ObjectToParameters;
29	import com.aspectran.utils.apon.Parameters;
30	import com.aspectran.utils.json.JsonWriter;
31	import com.aspectran.web.support.http.HttpMediaTypeNotAcceptableException;
32	import com.aspectran.web.support.http.HttpStatus;
33	import com.aspectran.web.support.http.MediaType;
34
35	import javax.xml.transform.TransformerException;
36	import java.io.IOException;
37	import java.io.Writer;
38	import java.nio.charset.Charset;
39	import java.util.Collections;
40	import java.util.List;
41	import java.util.Map;
42
43	/**
44	* The default RestResponse supports APON, JSON, and XML data types.
45	*
46	* <p>Created: 2019-06-16</p>
47	*/
48	public class DefaultRestResponse extends AbstractRestResponse {
49
50	private static final int MAX_INDENT = 8;
51
52	private static final List<MediaType> supportedContentTypes;
53	static {
54	supportedContentTypes = List.of(	×
55	MediaType.TEXT_PLAIN,
56	MediaType.TEXT_HTML,
57	MediaType.APPLICATION_JSON,
58	MediaType.APPLICATION_APON,
59	MediaType.APPLICATION_XML);
60	}
61
62	private static final Map<String, MediaType> supportedPathExtensions;
63	static {
64	supportedPathExtensions = Map.of(	×
65	"json", MediaType.APPLICATION_JSON,
66	"apon", MediaType.APPLICATION_APON,
67	"xml", MediaType.APPLICATION_XML,
68	"txt", MediaType.TEXT_PLAIN,
69	"html", MediaType.TEXT_HTML,
70	"htm", MediaType.TEXT_HTML);
71	}	×
72
73	public DefaultRestResponse() {
74	super();	×
75	}	×
76
77	public DefaultRestResponse(Object data) {
78	super(data);	×
79	}	×
80
81	public DefaultRestResponse(String label, Object data) {
82	super(label, data);	×
83	}	×
84
85	@Override
86	protected List<MediaType> getSupportedContentTypes() {
87	return supportedContentTypes;	×
88	}
89
90	@Override
91	protected MediaType getContentTypeByPathExtension(String extension) {
92	return supportedPathExtensions.get(extension);	×
93	}
94
95	@Override
96	public void transform(Activity activity) throws Exception {
97	Assert.notNull(activity, "activity must not be null");	×
98	ResponseAdapter responseAdapter = activity.getResponseAdapter();	×
99
100	MediaType acceptContentType;
101	try {
102	acceptContentType = determineAcceptContentType(activity);	×
103	} catch (HttpMediaTypeNotAcceptableException e) {	×
104	responseAdapter.setStatus(HttpStatus.NOT_ACCEPTABLE.value());	×
105	return;	×
106	}	×
107
108	MediaType responseContentType = determineResponseContentType(activity, acceptContentType);	×
109	responseAdapter.setContentType(responseContentType.toString());	×
110
111	transformByContentType(activity, acceptContentType);	×
112
113	if (getHeaders() != null) {	×
114	for (Map.Entry<String, List<String>> entry : getHeaders().entrySet()) {	×
115	String name = entry.getKey();	×
116	List<String> values = entry.getValue();	×
117	for (String value : values) {	×
118	responseAdapter.addHeader(name, value);	×
119	}	×
120	}	×
121	}
122
123	if (getStatus() > 0) {	×
124	responseAdapter.setStatus(getStatus());	×
125	}
126	}	×
127
128	protected void transformByContentType(Activity activity, MediaType contentType) throws Exception {
129	if (MediaType.APPLICATION_JSON.equalsTypeAndSubtype(contentType)) {	×
130	toJSON(activity, parseIndent(contentType));	×
131	} else if (MediaType.APPLICATION_APON.equalsTypeAndSubtype(contentType)) {	×
132	toAPON(activity, parseIndent(contentType));	×
133	} else if (MediaType.APPLICATION_XML.equalsTypeAndSubtype(contentType)) {	×
134	Charset charset = contentType.getCharset();	×
135	String encoding = (charset != null ? charset.name() : null);	×
136	toXML(activity, encoding, parseIndent(contentType));	×
137	} else {	×
138	toText(activity);	×
139	}
140	}	×
141
142	private void toJSON(@NonNull Activity activity, int indent) throws IOException {
143	RequestAdapter requestAdapter = activity.getRequestAdapter();	×
144	ResponseAdapter responseAdapter = activity.getResponseAdapter();	×
145	Writer writer = responseAdapter.getWriter();	×
146
147	// support for jsonp
148	String callback = requestAdapter.getParameter(JsonTransformResponse.CALLBACK_PARAM_NAME);	×
149	if (callback != null) {	×
150	writer.write(callback + JsonTransformResponse.ROUND_BRACKET_OPEN);	×
151	}
152	if (getName() != null \|\| getData() != null) {	×
153	StringifyContext stringifyContext = resolveStringifyContext(activity, indent);	×
154	JsonWriter jsonWriter = new JsonWriter(writer);	×
155	jsonWriter.setStringifyContext(stringifyContext);	×
156	if (getName() != null) {	×
157	jsonWriter.beginObject();	×
158	jsonWriter.writeName(getName());	×
159	}
160	jsonWriter.writeValue(getData());	×
161	if (getName() != null) {	×
162	jsonWriter.endObject();	×
163	}
164	}
165	if (callback != null) {	×
166	writer.write(JsonTransformResponse.ROUND_BRACKET_CLOSE);	×
167	}
168	}	×
169
170	private void toAPON(Activity activity, int indent) throws IOException {
171	if (getName() != null \|\| getData() != null) {	×
172	ResponseAdapter responseAdapter = activity.getResponseAdapter();	×
173	Writer writer = responseAdapter.getWriter();	×
174	StringifyContext stringifyContext = resolveStringifyContext(activity, indent);	×
175
176	Parameters parameters;
177	if (getName() != null) {	×
178	parameters = ObjectToParameters.from(getName(), getData(), stringifyContext);	×
179	} else {
180	parameters = ObjectToParameters.from(getData(), stringifyContext);	×
181	}
182
183	AponTransformResponse.transform(parameters, writer, stringifyContext);	×
184	}
185	}	×
186
187	private void toXML(Activity activity, String encoding, int indent) throws IOException, TransformerException {
188	if (getName() != null \|\| getData() != null) {	×
189	ResponseAdapter responseAdapter = activity.getResponseAdapter();	×
190	Writer writer = responseAdapter.getWriter();	×
191	StringifyContext stringifyContext = resolveStringifyContext(activity, indent);	×
192
193	Object data;
194	if (getName() != null) {	×
195	data = Collections.singletonMap(getName(), getData());	×
196	} else {
197	data = getData();	×
198	}
199	XmlTransformResponse.transform(data, writer, encoding, stringifyContext);	×
200	}
201	}	×
202
203	private void toText(Activity activity) throws IOException {
204	if (getName() != null \|\| getData() != null) {	×
205	ResponseAdapter responseAdapter = activity.getResponseAdapter();	×
206	Writer writer = responseAdapter.getWriter();	×
207	if (getData() != null) {	×
208	writer.write(ToStringBuilder.toString(getName(), getData()));	×
209	}
210	}
211	}	×
212
213	@NonNull
214	private StringifyContext resolveStringifyContext(@NonNull Activity activity, int indent) {
215	StringifyContext stringifyContext = getStringifyContext();	×
216	if (stringifyContext == null) {	×
217	stringifyContext = activity.getStringifyContext().clone();	×
218	} else {
219	stringifyContext.merge(activity.getStringifyContext());	×
220	}
UNCOV 221	if (stringifyContext.isPretty() && !stringifyContext.hasIndentSize() && indent > -1) {	×
222	stringifyContext.setIndentSize(indent);	×
223	}
UNCOV 224	return stringifyContext;	×
225	}
226
227	private int parseIndent(@NonNull MediaType contentType) {
228	try {
229	String indent = contentType.getParameter("indent");	×
230	if (indent != null) {	×
UNCOV 231	int depth = Integer.parseInt(indent);	×
232	return (Math.min(depth, MAX_INDENT));	×
233	}
234	} catch (NumberFormatException e) {	×
235	// ignored
UNCOV 236	}	×
UNCOV 237	return -1;	×
238	}
239
240	}

aspectran / aspectran / #4053

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous