private HttpServletRequest request;

private String service;

private String method = "";

private String[] path;

private java.security.Principal user;

private javaxt.utils.URL url;

private byte[] payload;

private JSONObject json;

private HashMap<String, List<String>> parameters; //<- Don't use this directly! Use the static getParameter() and setParameter() methods

private Field[] fields;

private Filter filter;

private Sort sort;

private Long limit;

private Long offset;

private Long id;

private boolean readOnly = false;

private boolean parseJson = false;

private static String[] approvedFunctions = new String[]{

"min", "max", "count", "avg", "sum"

};

private Map<String, String> keywords = Map.ofEntries(

Map.entry("fields", "fields"),

Map.entry("orderby", "orderby"),

Map.entry("limit", "limit"),

Map.entry("offset", "offset"),

//Used by the list method in the WebService class

Map.entry("format", "format"),

Map.entry("count", "count"),

//Legacy - may be removed in the future

Map.entry("filter", "filter"),

Map.entry("where", "where"),

Map.entry("page", "page")

);

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a JavaXT HttpServletRequest.

public ServiceRequest(javaxt.http.servlet.HttpServletRequest request){

this(null, request);

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a JavaXT HttpServletRequest.

public ServiceRequest(String service, javaxt.http.servlet.HttpServletRequest request){

this.request = request;

this.url = new javaxt.utils.URL(request.getURL());

this.parameters = url.getParameters();

//Parse payload if it contains URL encoded form data

String contentType = request.getContentType();

if (contentType!=null){

if (contentType.equalsIgnoreCase("application/x-www-form-urlencoded")){

byte[] b = getPayload();

if (b!=null && b.length>0){

try{

LinkedHashMap<String, List<String>> params =

javaxt.utils.URL.parseQueryString(new String(b, "UTF-8"));

for (String key : params.keySet()) {

List<String> values = params.get(key);

List<String> currValues = this.parameters.get(key);

if (currValues==null){

this.parameters.put(key, values);

}

else{

for (String val : values){

currValues.add(val);

}

}

}

}

catch(Exception e){}

}

}

}

//Update service (and path) after parsing params

setService(service);

//Get offset and limit

updateOffsetLimit();

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a "javax" HttpServletRequest

public ServiceRequest(javax.servlet.http.HttpServletRequest request,

javax.servlet.http.HttpServlet servlet){

this(new javaxt.http.servlet.HttpServletRequest(request, servlet));

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a "jakarta" HttpServletRequest

public ServiceRequest(jakarta.servlet.http.HttpServletRequest request,

jakarta.servlet.http.HttpServlet servlet){

this(new javaxt.http.servlet.HttpServletRequest(request, servlet));

}

//**************************************************************************

//** setService

//**************************************************************************

/** Used to update the service and path variables associated with the

public void setService(String service){

if (service!=null){

service = service.trim();

if (service.isEmpty()) service = null;

}

this.service = service;

//Parse path, excluding servlet

setPath(request.getPathInfo());

}

//**************************************************************************

//** getService

//**************************************************************************

/** Returns the service path in the request URL. Returns null if the service

public String getService(){

return service;

}

//**************************************************************************

//** getMethod

//**************************************************************************

/** Returns a method name for the HTTP request using the first path segment

public String getMethod(){

return method;

}

//**************************************************************************

//** setReadOnly

//**************************************************************************

/** Used to enable/disable insert, update, and delete operations by updating

public void setReadOnly(boolean readOnly){

if (readOnly==this.readOnly) return;

this.readOnly = readOnly;

setPath(request.getPathInfo());

}

//**************************************************************************

//** isReadOnly

//**************************************************************************

/** Returns true if insert, update, and delete operations have been disabled.

public boolean isReadOnly(){

return readOnly;

}

//**************************************************************************

//** getPath

//**************************************************************************

/** Returns a segment from the requested URL path at a given index. Note

public javaxt.utils.Value getPath(int i){

if (path==null || i>=path.length) return new javaxt.utils.Value(null);

else return new javaxt.utils.Value(path[i]);

}

//**************************************************************************

//** getPath

//**************************************************************************

/** Returns a part of the requested URL path after the servlet and service.

public String getPath(){

if (path==null) return null;

StringBuilder str = new StringBuilder();

for (String s : path){

str.append("/");

str.append(s);

}

return str.toString();

}

//**************************************************************************

//** setPath

//**************************************************************************

/** Used to update the path variable associated with the request. The path

public void setPath(String path){

this.path = null;

if (path!=null){

boolean addPath = service==null;

//Special case for service

if (service!=null && service.contains("/")){

int idx = path.indexOf(service);

if (idx>-1) path = path.substring(idx+service.length());

addPath = true;

}

if (path.startsWith("/")) path = path.substring(1);

ArrayList<String> arr = new ArrayList<>();

for (String str : path.split("/")){

if (addPath) arr.add(str);

if (str.equalsIgnoreCase(service)){

addPath = true;

}

}

if (!arr.isEmpty()){

this.path = arr.toArray(new String[arr.size()]);

}

}

//Generate a method name using the request method and first "directory"

//in the path. Example: "GET /config/users" would yield the "getUsers"

//from the "config" service.

String name = getPath(0).toString();

if (name!=null && name.length()>0){

name = name.substring(0, 1).toUpperCase() + name.substring(1);

if (readOnly){

this.method = "get" + name;

}

else{

String method = request.getMethod();

if (method.equals("GET")){

this.method = "get" + name;

}

else if (method.equals("PUT") || method.equals("POST")){

this.method = "save" + name;

}

else if (method.equals("DELETE")){

this.method = "delete" + name;

}

}

}

//Get ID

id = getPath(1).toLong();

if (id==null) id = getParameter("id").toLong();

}

//**************************************************************************

//** getID

//**************************************************************************

/** Returns the ID associated with the request. Assuming the service request

public Long getID(){

return id;

}

//**************************************************************************

//** getURL

//**************************************************************************

/** Returns the original url used to make the request.

public javaxt.utils.URL getURL(){

return url;

}

//**************************************************************************

//** getParameter

//**************************************************************************

/** Returns the value associated with a parameter in the request. Performs a

public javaxt.utils.Value getParameter(String key){

Object val = null;

if (key!=null){

//Search the URL querystring

List<String> parameters = getParameter(key, this.parameters);

if (parameters!=null){

LinkedHashSet<String> vals = new LinkedHashSet<>();

for (String v : parameters){

if (v.length()>0){

if (v.equalsIgnoreCase("null")) v = null;

}

else{

v = null;

}

if (v!=null) vals.add(v);

}

if (!vals.isEmpty()){

if (vals.size()==1){

val = vals.iterator().next();

}

else{

val = vals.toArray(new String[vals.size()]);

}

}

}

//If nothing found in the querystring, search the payload as directed

if (val==null && parseJson){ //&& !getRequest().getMethod().equals("GET")

JSONObject json = getJson();

if (json!=null && json.has(key)){

return new javaxt.utils.Value(json.get(key).toObject());

}

}

}

return new javaxt.utils.Value(val);

}

//**************************************************************************

//** hasParameter

//**************************************************************************

/** Returns true if the request contains a given parameter in the request.

public boolean hasParameter(String key){

if (key!=null){

List<String> parameters = getParameter(key, this.parameters);

if (parameters!=null) return true;

if (parseJson){ //&& !getRequest().getMethod().equals("GET")

JSONObject json = getJson();

if (json!=null && json.has(key)){

return true;

}

}

}

return false;

}

//**************************************************************************

//** setParameter

//**************************************************************************

/** Used to update a parameter extracted from the original request. Performs

public void setParameter(String key, String val){

if (key==null) return;

if (val==null){

removeParameter(key, this.parameters);

}

else{

//Get parameters

List<String> parameters = getParameter(key, this.parameters);

//Special case for classes that override the hasParameter and

//getParameter methods.

if (parameters==null && hasParameter(key)){

parameters = new ArrayList<>();

parameters.add(getParameter(key).toString());

setParameter(key, parameters, this.parameters);

}

//Add or update value

if (parameters==null){

if (val!=null){

parameters = new ArrayList<>();

parameters.add(val);

setParameter(key, parameters, this.parameters);

}

}

else{

if (val!=null) parameters.set(0, val);

}

}

//Update offset and limit as needed

String k = key.toLowerCase();

if (k.equals(getKeyword("offset")) ||

k.equals(getKeyword("limit")) ||

k.equals(getKeyword("page"))){

updateOffsetLimit();

}

}

//**************************************************************************

//** removeParameter

//**************************************************************************

/** Used to remove a parameter from the request. Performs a case insensitive

public void removeParameter(String key){

setParameter(key, null);

}

//**************************************************************************

//** getParameterNames

//**************************************************************************

/** Returns a list of all the parameter keywords found in this request.

public String[] getParameterNames(){

LinkedHashSet<String> keys = new LinkedHashSet<>();

Iterator<String> it = this.parameters.keySet().iterator();

while (it.hasNext()) keys.add(it.next());

if (parseJson){

JSONObject json = getJson();

if (json!=null){

for (String key : json.keySet()){

keys.add(key);

}

}

}

return keys.toArray(new String[keys.size()]);

}

private static List<String> getParameter(String key, HashMap<String, List<String>> parameters){

return javaxt.utils.URL.getParameter(key, parameters);

};

private static void setParameter(String key, List<String> values, HashMap<String, List<String>> parameters){

javaxt.utils.URL.setParameter(key, values, parameters);

}

private static void removeParameter(String key, HashMap<String, List<String>> parameters){

javaxt.utils.URL.removeParameter(key, parameters);

}

//**************************************************************************

//** updateOffsetLimit

//**************************************************************************

private void updateOffsetLimit(){

offset = getParameter(getKeyword("offset")).toLong();

limit = getParameter(getKeyword("limit")).toLong();

Long page = getParameter(getKeyword("page")).toLong();

if (offset==null && page!=null){

if (limit==null) limit = 25L;

offset = (page*limit)-limit;

}

}

//**************************************************************************

//** getOffset

//**************************************************************************

/** Returns the value of the "offset" parameter in the request as a number.

public Long getOffset(){

return offset;

}

//**************************************************************************

//** getLimit

//**************************************************************************

/** Returns the value of the "limit" parameter in the request as a number.

public Long getLimit(){

return limit;

}

//**************************************************************************

//** getFormat

//**************************************************************************

/** Returns the value of the "format" parameter in the request.

protected String getFormat(){

String format = getParameter(getKeyword("format")).toString();

if (format==null) return "";

else return format.toLowerCase();

}

//**************************************************************************

//** getCount

//**************************************************************************

/** Returns the value of the "count" parameter in the request.

protected boolean getCount(){

Boolean count = getParameter(getKeyword("count")).toBoolean();

if (count==null) return false;

else return count;

}

//**************************************************************************

//** getClientIP

//**************************************************************************

/** Returns the client IP address from the request (the direct socket

public String getClientIP() {

return getClientIP(false);

}

//**************************************************************************

//** getClientIP

//**************************************************************************

/** Returns the client IP address from the request.

public String getClientIP(boolean trustProxy) {

if (trustProxy) {

String xff = request.getHeader("X-Forwarded-For");

if (xff != null && !xff.isEmpty()) {

int comma = xff.indexOf(",");

String forwarded = (comma > 0 ? xff.substring(0, comma) : xff).trim();

if (!forwarded.isEmpty()) return forwarded;

}

}

String ip = request.getRemoteAddr();

if (ip != null && ip.startsWith("/") && ip.length() > 1) {

ip = ip.substring(1);

}

return ip;

}

//**************************************************************************

//** getRequest

//**************************************************************************

/** Returns the original, unmodified HTTP request used to instantiate this

public HttpServletRequest getRequest(){

return request;

}

//**************************************************************************

//** setPayload

//**************************************************************************

/** Used to update the raw bytes representing the payload of the request

public void setPayload(byte[] payload){

this.payload = payload;

json = null;

}

//**************************************************************************

//** getPayload

//**************************************************************************

/** Returns the raw bytes from the payload of the request

public byte[] getPayload(){

if (payload==null){

try{

payload = request.getBody();

}

catch(Exception e){}

}

return payload;

}

//**************************************************************************

//** getJson

//**************************************************************************

/** Returns the payload of the request as a JSON object

public JSONObject getJson(){

if (json==null){

byte[] b = getPayload();

if (b!=null && b.length>0){

try{

json = new JSONObject(new String(b, "UTF-8"));

}

catch(Exception e){}

}

}

return json;

}

//**************************************************************************

//** parseJson

//**************************************************************************

/** Calling this method will expand parameter searches into the payload of

public void parseJson(){

parseJson = true;

if (id==null) id = getParameter("id").toLong();

updateOffsetLimit();

}

//**************************************************************************

//** getUser

//**************************************************************************

/** Returns the user associated with the request

public java.security.Principal getUser(){

if (user==null){

user = request.getUserPrincipal();

}

return user;

}

//**************************************************************************

//** getCredentials

//**************************************************************************

/** Returns the credentials associated with an HTTP request. The credentials

public String[] getCredentials(){

return request.getCredentials();

}

//**************************************************************************

//** authenticate

//**************************************************************************

/** Used to authenticate a client request. Authentication is performed by a

public void authenticate() throws ServletException {

request.authenticate();

}

//**************************************************************************

//** isCacheable

//**************************************************************************

/** Returns true if a given eTag matches the "if-none-match" request header.

public boolean isCacheable(String eTag, String date){

String matchTag = request.getHeader("if-none-match");

String cacheControl = request.getHeader("cache-control");

if (matchTag==null) matchTag = "";

if (cacheControl==null) cacheControl = "";

if (cacheControl.equalsIgnoreCase("no-cache")==false){

if (eTag.equalsIgnoreCase(matchTag)){

return true;

}

else{

//Internet Explorer 6 uses "if-modified-since" instead of "if-none-match"

matchTag = request.getHeader("if-modified-since");

if (matchTag!=null){

for (String tag: matchTag.split(";")){

if (tag.trim().equalsIgnoreCase(date)){

return true;

}

}

}

}

}

return false;

}

//**************************************************************************

//** getFields

//**************************************************************************

/** Returns an array of ServiceRequest.Fields by parsing the "fields"

public Field[] getFields(){

if (fields!=null) return fields;

String fields = getParameter(getKeyword("fields")).toString();

//If fields are empty, simply return an ampty array

if (fields==null || fields.length()==0){

this.fields = new Field[0];

return this.fields;

}

//Parse the fields

this.fields = getFields(fields);

return this.fields;

}

//**************************************************************************

//** getFields

//**************************************************************************

/** Used to parse a given String into an array of Fields.

public Field[] getFields(String fields){

ArrayList<Field> arr = new ArrayList<>();

try{

//Parse fields parameter using JSQLParser

CCJSqlParserManager parserManager = new CCJSqlParserManager();

Select select = (Select) parserManager.parse(new StringReader("SELECT " + fields + " FROM T"));

PlainSelect plainSelect = (PlainSelect) select.getSelectBody();

//Iterate through the fields and update the array

Iterator<SelectItem> it = plainSelect.getSelectItems().iterator();

while (it.hasNext()){

SelectExpressionItem si = (SelectExpressionItem) it.next();

Expression expression = si.getExpression();

String alias = si.getAlias()==null ? null : si.getAlias().getName();

//Check if the expression contains a function

String functionName = null;

try{

Function f = (Function) expression;

functionName = f.getName().toLowerCase();

}

catch(Exception e){

try{

SubSelect ss = (SubSelect) expression;

functionName = "SELECT";

}

catch(Exception ex){

}

}

String column = expression.toString();

boolean isFunction = functionName!=null;

if (!isFunction) column = StringUtils.camelCaseToUnderScore(column);

Field field = new Field(column);

field.setAlias(alias);

field.isFunction(isFunction);

field.setFunctionName(functionName);

arr.add(field);

}

}

catch(Throwable e){

//JSQLParser doesn't like one of the fields or JSqlParser is missing

//from the class path. If so, fallback to the JavaXT SQL parser.

arr.clear();

javaxt.sql.Parser sqlParser = new javaxt.sql.Parser("SELECT " + fields + " FROM T");

for (javaxt.sql.Parser.SelectStatement stmt : sqlParser.getSelectStatements()){

String column = stmt.getField();

boolean isFunction = stmt.isFunction();

if (!isFunction) column = StringUtils.camelCaseToUnderScore(column);

Field field = new Field(column);

field.setAlias(stmt.getAlias());

field.isFunction(isFunction);

arr.add(field);

}

}

return arr.toArray(new Field[arr.size()]);

}

//**************************************************************************

//** getFilter

//**************************************************************************

/** Returns a ServiceRequest.Filter by parsing the query string associated

public Filter getFilter(){

if (filter!=null) return filter;

//Parse querystring

LinkedHashMap<String, javaxt.utils.Value> params = new LinkedHashMap<>();

if (hasParameter(getKeyword("filter"))){

String str = getParameter(getKeyword("filter")).toString();

if (str.startsWith("{") && str.endsWith("}")){

JSONObject json = new JSONObject(str);

for (String key : json.keySet()){

params.put(key, json.get(key));

}

}

else{

LinkedHashMap<String, List<String>> map = javaxt.utils.URL.parseQueryString(str);

for (String key : map.keySet()){

List<String> vals = map.get(key);

if (!vals.isEmpty()) params.put(key, new javaxt.utils.Value(vals.get(0)));

}

}

}

else{

for (String key : getParameterNames()){

params.put(key, getParameter(key));

}

}

//Create filter

filter = new Filter();

HashSet<String> reservedKeywords = getKeywords();

for (String key : params.keySet()){

key = key.trim();

if (key.isEmpty()) continue;

if (key.equals("_")) continue;

if (reservedKeywords.contains(key.toLowerCase())) continue;

//Parse val

String[] vals;