001package org.conqat.engine.service.shared.client;
002
003import java.nio.charset.StandardCharsets;
004import java.util.List;
005import java.util.Optional;
006
007import org.apache.http.HttpEntity;
008import org.apache.http.NameValuePair;
009import org.apache.http.client.utils.URLEncodedUtils;
010import org.apache.http.entity.StringEntity;
011import org.conqat.engine.commons.util.JsonUtils;
012import org.conqat.engine.service.shared.EMimeType;
013import org.conqat.engine.service.shared.XmlSerializationUtils;
014
015/**
016 * Provides a serialization strategy for service calls.
017 */
018public interface ISerializationFormat<T> {
019
020        /**
021         * Returns the MIME type that should be sent to the server as "Content-Type"
022         * header. May return empty to indicate that the Content-Type header should not
023         * be set.
024         */
025        Optional<EMimeType> getMimeType();
026
027        /** Returns the serialized data. */
028        String serialize(T data);
029
030        /** Serializes the given data and wraps it into an HttpEntity. */
031        default HttpEntity toHttpEntity(T data) {
032                return new StringEntity(serialize(data), StandardCharsets.UTF_8);
033        }
034
035        /** Constructs a generic XML serializer. */
036        static <T> ISerializationFormat<T> toXml() {
037                return new ISerializationFormat<T>() {
038                        @Override
039                        public Optional<EMimeType> getMimeType() {
040                                return Optional.of(EMimeType.XML);
041                        }
042
043                        @Override
044                        public String serialize(T data) {
045                                return XmlSerializationUtils.serializeToXML(data);
046                        }
047                };
048        }
049
050        /** Constructs a generic JSON serializer. */
051        static <T> ISerializationFormat<T> toJson() {
052                return new ISerializationFormat<T>() {
053                        @Override
054                        public Optional<EMimeType> getMimeType() {
055                                return Optional.of(EMimeType.JSON);
056                        }
057
058                        @Override
059                        public String serialize(T data) {
060                                return JsonUtils.serializeToJSON(data);
061                        }
062                };
063        }
064
065        /**
066         * Constructs a serializer that just passes the given data without any
067         * serialization as plain text.
068         */
069        static ISerializationFormat<String> asPlainText() {
070                return new ISerializationFormat<String>() {
071                        @Override
072                        public Optional<EMimeType> getMimeType() {
073                                return Optional.of(EMimeType.PLAIN);
074                        }
075
076                        @Override
077                        public String serialize(String data) {
078                                return data;
079                        }
080                };
081        }
082
083        /**
084         * Constructs a serializer, which expects a List<NameValuePair> and sends them
085         * as url encoded form data.
086         */
087        static ISerializationFormat<List<NameValuePair>> toUrlEncodedFormData() {
088                return new ISerializationFormat<List<NameValuePair>>() {
089                        @Override
090                        public Optional<EMimeType> getMimeType() {
091                                return Optional.of(EMimeType.URL_ENCODED_FORM_DATA);
092                        }
093
094                        @Override
095                        public String serialize(List<NameValuePair> data) {
096                                return URLEncodedUtils.format(data, StandardCharsets.UTF_8);
097                        }
098                };
099        }
100
101        /**
102         * Constructs a serializer, which expects a raw HttpEntity that should be sent
103         * as multipart form data.
104         */
105        static ISerializationFormat<HttpEntity> toMultiPart() {
106                return new ISerializationFormat<HttpEntity>() {
107                        @Override
108                        public Optional<EMimeType> getMimeType() {
109                                return Optional.empty();
110                        }
111
112                        @Override
113                        public String serialize(HttpEntity data) {
114                                throw new IllegalStateException("This should never be called directly. Call via toHttpEntity().");
115                        }
116
117                        @Override
118                        public HttpEntity toHttpEntity(HttpEntity data) {
119                                return data;
120                        }
121                };
122        }
123}