Problem.java

  1. package de.turnertech.problemdetails;

  3. import java.io.ByteArrayOutputStream;
  4. import java.io.IOException;
  5. import java.io.OutputStream;
  6. import java.io.PrintWriter;
  7. import java.net.URI;
  8. import java.nio.charset.Charset;
  9. import java.nio.charset.StandardCharsets;
  10. import java.security.InvalidParameterException;
  11. import java.util.Locale;
  12. import java.util.Objects;
  13. import java.util.ResourceBundle;

  15. import javax.xml.stream.XMLOutputFactory;
  16. import javax.xml.stream.XMLStreamException;
  17. import javax.xml.stream.XMLStreamWriter;

  19. /**
  20.  * A POJO representation of the urn:ietf:rfc:7807 problem type.
  21.  */
  22. public class Problem {
  23.     
  24.     /** urn:ietf:rfc:7807 */
  25.     public static final String NAMESPACE = "urn:ietf:rfc:7807";
  26.     
  27.     /** application/problem+xml */
  28.     public static final String MEDIA_TYPE_XML = "application/problem+xml";
  29.     
  30.     /** application/problem+json */
  31.     public static final String MEDIA_TYPE_JSON = "application/problem+json";
  32.     
  33.     private static final ResourceBundle i18n = ResourceBundle.getBundle("de.turnertech.problemdetails.i18n");

  35.     private static final String PROBLEM_STRING = "problem";
  36.     
  37.     // Mandatory with default
  38.     private URI type;
  39.     
  40.     // Optional, must be same as HTTP response if present
  41.     private Integer status;
  42.     
  43.     // Advisory
  44.     private String title;
  45.     
  46.     // Optional
  47.     private String detail;
  48.     
  49.     // Optional
  50.     private URI instance;

  52.     /**
  53.      * Constructs an empty Problem with the type "about:blank" (RFC 9457 - 4.2.1.).
  54.      */
  55.     public Problem() {
  56.         this(URI.create("about:blank"));
  57.     }

  59.     /**
  60.      * Constructs a Problem with the provided parameters. Note that type may not be null.
  61.      * @param type RFC 9457 - 3.1.1.
  62.      * @throws NullPointerException if type is null.
  63.      */
  64.     public Problem(URI type) {
  65.         this(type, null);
  66.     }

  68.     /**
  69.      * Constructs a Problem with the provided parameters. Note that type may not be null.
  70.      * @param type RFC 9457 - 3.1.1.
  71.      * @param instance RFC 9457 - 3.1.5.
  72.      * @throws NullPointerException if type is null.
  73.      */
  74.     public Problem(URI type, URI instance) throws NullPointerException {
  75.         this.type = Objects.requireNonNull(type, i18n.getString("error.type.nonnull"));
  76.         this.instance = instance;
  77.     }
  78.     
  79.     /**
  80.      * Constructs a deep copy of the provided problem. If you extend this class, make sure
  81.      * that your implementation of the copy constructor also returns deep copies.
  82.      * @param other problem to copy.
  83.      */
  84.     public Problem(Problem other) {
  85.         this.type = other.type;
  86.         this.status = other.status;
  87.         this.title = other.title;
  88.         this.detail = other.detail;
  89.         this.instance = other.instance;
  90.     }

  92.     /**
  93.      * Gets the problem type.
  94.      * @return the problem type.
  95.      */
  96.     public URI getType() {
  97.         return type;
  98.     }

  100.     /**
  101.      * Sets the problem type.
  102.      * @param type the problem type.
  103.      * @throws NullPointerException if type is null
  104.      */
  105.     public void setType(URI type) throws NullPointerException {
  106.         this.type = Objects.requireNonNull(type, i18n.getString("error.type.nonnull"));
  107.     }

  109.     /**
  110.      * Gets the problem status code (HTTP Status Code).
  111.      * @return the problem status code (HTTP Status Code)
  112.      */
  113.     public Integer getStatus() {
  114.         return status;
  115.     }

  117.     /**
  118.      * Sets the problem status code (HTTP Status Code). If set, this must be the same as the one used in your HTTP Response.
  119.      * @param status the problem status code (HTTP Status Code).
  120.      * @see #findStatusPhrase(int)
  121.      */
  122.     public void setStatus(Integer status) {
  123.         if(status != null && (status < 100 || status > 599)) {
  124.             throw new InvalidParameterException(i18n.getString("error.status.inrange"));
  125.         }
  126.         this.status = status;
  127.     }

  129.     /**
  130.      * Gets the problem title.
  131.      * @return the problem title.
  132.      */
  133.     public String getTitle() {
  134.         return title;
  135.     }

  137.     /**
  138.      * Sets the problem title.
  139.      * @param title the short human readable title.
  140.      * @see #findStatusPhrase(int)
  141.      */
  142.     public void setTitle(String title) {
  143.         this.title = title;
  144.     }

  146.     /**
  147.      * Gets the problem detail.
  148.      * @return the problem detail.
  149.      */
  150.     public String getDetail() {
  151.         return detail;
  152.     }

  154.     /**
  155.      * Sets the problem detail.
  156.      * @param detail the problem detail.
  157.      */
  158.     public void setDetail(String detail) {
  159.         this.detail = detail;
  160.     }

  162.     /**
  163.      * Gets the problem instance.
  164.      * @return the problem instance.
  165.      */
  166.     public URI getInstance() {
  167.         return instance;
  168.     }

  170.     /**
  171.      * Sets the problem instance.
  172.      * @param instance the problem instance.
  173.      */
  174.     public void setInstance(URI instance) {
  175.         this.instance = instance;
  176.     }

  178.     /**
  179.      * Helper for retrieving the HTTP Status Phrase for a HTTP Status Code.
  180.      * @param statusCode the HTTP Status Code.
  181.      * @return the HTTP Status Phrase in English, may be null.
  182.      * @see #findStatusPhrase(int, Locale)
  183.      */
  184.     public static String findStatusPhrase(int statusCode) {
  185.         return findStatusPhrase(statusCode, Locale.ENGLISH);
  186.     }

  188.     /**
  189.      * Helper for retrieving the localised HTTP Status Phrase for a HTTP Status Code.
  190.      * @param statusCode the HTTP Status Code.
  191.      * @param locale the desired language.
  192.      * @return the HTTP Status Phrase, may be null.
  193.      * @see #findStatusPhrase(int)
  194.      */
  195.     public static String findStatusPhrase(int statusCode, Locale locale) {
  196.         ResourceBundle strings = ResourceBundle.getBundle("de.turnertech.problemdetails.i18n", locale);
  197.         return strings.getString(Integer.toString(statusCode));
  198.     }
  199.     
  200.     /**
  201.      * Converts the contents to a String containing the JSON representation of this Problem.
  202.      * @return the JSON String.
  203.      * @throws IOException if there are problems with extending the JSON.
  204.      * @see #extendJson(OutputStream, Charset)
  205.      * @see #toJson(OutputStream)
  206.      * @see #toJson(OutputStream, Charset)
  207.      */
  208.     public String toJson() throws IOException {
  209.         try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
  210.             toJson(outputStream);
  211.             return outputStream.toString(StandardCharsets.UTF_8);
  212.         }
  213.     }

  215.     /**
  216.      * Writes the Problem to the supplied stream in JSON format using UTF-8.
  217.      * @param outputStream the stream to write to.
  218.      * @throws IOException if there are problems with extending the JSON.
  219.      * @see #extendJson(OutputStream, Charset)
  220.      * @see #toJson()
  221.      * @see #toJson(OutputStream, Charset)
  222.      */
  223.     public void toJson(OutputStream outputStream) throws IOException {
  224.         toJson(outputStream, StandardCharsets.UTF_8);
  225.     }

  227.     /**
  228.      * Writes the Problem to the supplied stream in JSON format using the supplied Charset.
  229.      * @param outputStream the stream to write to.
  230.      * @param charset the Charset to use.
  231.      * @throws IOException if there are problems with extending the JSON.
  232.      */
  233.     public void toJson(OutputStream outputStream, Charset charset) throws IOException {
  234.         try(PrintWriter printWriter = new PrintWriter(outputStream)) {
  235.             printWriter.write("{\"type\":\"");
  236.             printWriter.write(type.toString());
  237.             printWriter.write("\"");

  239.             if(title != null) {
  240.                 printWriter.write(",\"title\":\"");
  241.                 printWriter.write(title);
  242.                 printWriter.write("\"");
  243.             }
  244.             if(status != null) {
  245.                 printWriter.write(",\"status\":\"");
  246.                 printWriter.write(Integer.toString(status));
  247.                 printWriter.write("\"");
  248.             }
  249.             if(detail != null) {
  250.                 printWriter.write(",\"detail\":\"");
  251.                 printWriter.write(detail);
  252.                 printWriter.write("\"");
  253.             }
  254.             if(instance != null) {
  255.                 printWriter.write(",\"instance\":\"");
  256.                 printWriter.write(instance.toString());
  257.                 printWriter.write("\"");
  258.             }

  260.             printWriter.flush();

  262.         }

  264.         extendJson(outputStream, charset);

  266.         outputStream.write("}".getBytes(charset));
  267.     }

  269.     /**
  270.      * <p>Override this if you wish to extend the JSON response. This function is called directly before
  271.      * closing the problem element. Pay carefull attention to the namespaces!</p>
  272.      * @param outputStream the stream to write to
  273.      * @param charset the charset this XML is being written in
  274.      * @return true if an element was inserted (so that the caller can decide whether or not to write a ",")
  275.      */
  276.     protected boolean extendJson(OutputStream outputStream, Charset charset) {
  277.         // Called before closing the last element.
  278.         return false;
  279.     }

  281.     /**
  282.      * Converts the contents to a String containing the XML representation of this Problem.
  283.      * @return the XML String.
  284.      * @throws XMLStreamException if there are problems with extending the XML.
  285.      * @see #extendXml(XMLStreamWriter, Charset)
  286.      * @see #toXml(OutputStream, Charset, boolean)
  287.      * @see #toXml(XMLStreamWriter, Charset, boolean)
  288.      */
  289.     public String toXml() throws XMLStreamException {
  290.         try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
  291.             toXml(outputStream, StandardCharsets.UTF_8, true);
  292.             return outputStream.toString(StandardCharsets.UTF_8);
  293.         } catch (IOException e) {
  294.             return null;
  295.         }
  296.     }
  297.     
  298.     /**
  299.      * Writes the Problem to the supplied stream in XML format using the supplied charset.
  300.      * @param outputStream to write to.
  301.      * @param charset to write using.
  302.      * @param writeStartDocument to indicate if the xml start document should also be written.
  303.      * @throws XMLStreamException if there are problems with extending the XML.
  304.      */
  305.     public void toXml(OutputStream outputStream, Charset charset, boolean writeStartDocument) throws XMLStreamException {
  306.         XMLOutputFactory outputFactory = XMLOutputFactory.newFactory();
  307.         outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, true);
  308.         XMLStreamWriter xmlStreamWriter = outputFactory.createXMLStreamWriter(outputStream, charset.toString());
  309.         toXml(xmlStreamWriter, charset, writeStartDocument);
  310.     }
  311.     
  312.     /**
  313.      * Writes the Problem to the supplied writer in XML format using the supplied charset.
  314.      * @param xmlStreamWriter to write using.
  315.      * @param charset to write using.
  316.      * @param writeStartDocument to indicate if the xml start document should also be written.
  317.      * @throws XMLStreamException if there are problems with extending the XML.
  318.      */
  319.     public void toXml(XMLStreamWriter xmlStreamWriter, Charset charset, boolean writeStartDocument) throws XMLStreamException {
  320.         if(writeStartDocument) {
  321.             xmlStreamWriter.writeStartDocument(charset.toString(), "1.0");
  322.         }
  323.         
  324.         String defaultNs = xmlStreamWriter.getNamespaceContext().getNamespaceURI("");
  325.         String prefix = xmlStreamWriter.getNamespaceContext().getPrefix(NAMESPACE);
  326.         
  327.         if(prefix != null) {
  328.             xmlStreamWriter.writeStartElement(NAMESPACE, PROBLEM_STRING);
  329.         } else if(defaultNs == null) {
  330.             xmlStreamWriter.writeStartElement(PROBLEM_STRING);
  331.             xmlStreamWriter.writeDefaultNamespace(NAMESPACE);
  332.         } else {
  333.             prefix = "p";
  334.             int i = 0;
  335.             while(xmlStreamWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
  336.                 prefix = "p" + Integer.toString(i);
  337.             }
  338.             xmlStreamWriter.writeStartElement(prefix, PROBLEM_STRING, NAMESPACE);
  339.             xmlStreamWriter.writeNamespace(prefix, NAMESPACE);
  340.         }
  341.         
  342.         if(type != null) {
  343.             xmlStreamWriter.writeStartElement(NAMESPACE, PROBLEM_STRING);
  344.             xmlStreamWriter.writeCharacters(type.toString());
  345.             xmlStreamWriter.writeEndElement();
  346.         }

  348.         if(title != null) {
  349.             xmlStreamWriter.writeStartElement(NAMESPACE, "title");
  350.             xmlStreamWriter.writeCharacters(title);
  351.             xmlStreamWriter.writeEndElement();
  352.         }

  354.         if(status != null) {
  355.             xmlStreamWriter.writeStartElement(NAMESPACE, "status");
  356.             xmlStreamWriter.writeCharacters(Integer.toString(status));
  357.             xmlStreamWriter.writeEndElement();
  358.         }

  360.         if(detail != null) {
  361.             xmlStreamWriter.writeStartElement(NAMESPACE, "detail");
  362.             xmlStreamWriter.writeCharacters(detail);
  363.             xmlStreamWriter.writeEndElement();
  364.         }

  366.         if(instance != null) {
  367.             xmlStreamWriter.writeStartElement(NAMESPACE, "instance");
  368.             xmlStreamWriter.writeCharacters(instance.toString());
  369.             xmlStreamWriter.writeEndElement();
  370.         }
  371.         
  372.         extendXml(xmlStreamWriter, charset);
  373.         
  374.         // /problem
  375.         xmlStreamWriter.writeEndElement();
  376.         
  377.         if(writeStartDocument) {
  378.             xmlStreamWriter.writeEndDocument();
  379.         }
  380.     }
  381.     
  382.     /**
  383.      * Override this if you wish to extend the XML response. This function is called directly before
  384.      * closing the problem element. Pay carefull attention to the namespaces!
  385.      * @param xmlStreamWriter the writer you must use to write to the stream
  386.      * @param charset the charset this XML is being written in
  387.      * @throws XMLStreamException if there are problems with extending the XML.
  388.      */
  389.     protected void extendXml(XMLStreamWriter xmlStreamWriter, Charset charset) throws XMLStreamException {
  390.         // Called before closing the last element.
  391.     }

  393.     /**
  394.      * {@inheritDoc}
  395.      */
  396.     @Override
  397.     public int hashCode() {
  398.         final int prime = 31;
  399.         int result = 1;
  400.         result = prime * result + ((type == null) ? 0 : type.hashCode());
  401.         result = prime * result + ((status == null) ? 0 : status.hashCode());
  402.         result = prime * result + ((title == null) ? 0 : title.hashCode());
  403.         result = prime * result + ((detail == null) ? 0 : detail.hashCode());
  404.         result = prime * result + ((instance == null) ? 0 : instance.hashCode());
  405.         return result;
  406.     }

  408.     /**
  409.      * {@inheritDoc}
  410.      */
  411.     @Override
  412.     public boolean equals(Object obj) {
  413.         if (this == obj)
  414.             return true;
  415.         if (obj == null)
  416.             return false;
  417.         if (getClass() != obj.getClass())
  418.             return false;
  419.         Problem other = (Problem) obj;
  420.         if (type == null) {
  421.             if (other.type != null)
  422.                 return false;
  423.         } else if (!type.equals(other.type))
  424.             return false;
  425.         if (status == null) {
  426.             if (other.status != null)
  427.                 return false;
  428.         } else if (!status.equals(other.status))
  429.             return false;
  430.         if (title == null) {
  431.             if (other.title != null)
  432.                 return false;
  433.         } else if (!title.equals(other.title))
  434.             return false;
  435.         if (detail == null) {
  436.             if (other.detail != null)
  437.                 return false;
  438.         } else if (!detail.equals(other.detail))
  439.             return false;
  440.         if (instance == null) {
  441.             if (other.instance != null)
  442.                 return false;
  443.         } else if (!instance.equals(other.instance))
  444.             return false;
  445.         return true;
  446.     }

  448.     /**
  449.      * {@inheritDoc}
  450.      */
  451.     @Override
  452.     public String toString() {
  453.         return "Problem [type=" + type + ", title=" + title + "]";
  454.     }
  455.     
  456. }
Created with JaCoCo 0.8.11.202310140853