diff --git a/src/main/.DS_Store b/src/main/.DS_Store
new file mode 100644
index 0000000..d94e183
--- /dev/null
+++ b/src/main/.DS_Store
Binary files differ
diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store
new file mode 100644
index 0000000..e282944
--- /dev/null
+++ b/src/main/java/.DS_Store
Binary files differ
diff --git a/src/main/java/de/.DS_Store b/src/main/java/de/.DS_Store
new file mode 100644
index 0000000..b276992
--- /dev/null
+++ b/src/main/java/de/.DS_Store
Binary files differ
diff --git a/src/main/java/de/ids_mannheim/.DS_Store b/src/main/java/de/ids_mannheim/.DS_Store
new file mode 100644
index 0000000..07256f1
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/.DS_Store
Binary files differ
diff --git a/src/main/java/de/ids_mannheim/korap/.DS_Store b/src/main/java/de/ids_mannheim/korap/.DS_Store
new file mode 100644
index 0000000..e540d83
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/.DS_Store
Binary files differ
diff --git a/src/main/java/de/ids_mannheim/korap/auditing/AuditRecord.java b/src/main/java/de/ids_mannheim/korap/auditing/AuditRecord.java
new file mode 100644
index 0000000..28f915d
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/auditing/AuditRecord.java
@@ -0,0 +1,157 @@
+package de.ids_mannheim.korap.auditing;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.databind.JsonNode;
+import de.ids_mannheim.korap.utils.JsonUtils;
+import de.ids_mannheim.korap.utils.TimeUtils;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Arrays;
+
+/**
+ * @author hanl
+ *         <p/>
+ *         Record holder for auditing requests. Holds the data until it can be persisted to a database
+ */
+@Getter
+@Setter
+public class AuditRecord {
+
+    // fixme: handle via status codes
+    @Deprecated
+    public enum Operation {
+        GET, INSERT, UPDATE, DELETE, CREATE
+    }
+
+    public enum CATEGORY {
+        SECURITY, DATABASE, RESOURCE, QUERY, SERVICE
+    }
+
+    @JsonIgnore
+    private Integer id;
+    //security access describes changes in user authorities and access control permissions of resources
+    private String userid;
+    private String target;
+
+    //fixme: replace with more specific error codes
+    private CATEGORY category;
+    private String loc;
+    private Long timestamp;
+    private Integer status = -1;
+    private String args;
+    private String field_1 = "None";
+
+    private AuditRecord() {
+        this.timestamp = TimeUtils.getNow().getMillis();
+    }
+
+    public AuditRecord(CATEGORY category) {
+        this();
+        this.category = category;
+    }
+
+    public AuditRecord(CATEGORY cat, Object userID, Integer status) {
+        this(cat);
+        this.status = status;
+        if (userID != null) {
+            //todo: client info!
+            //            this.loc = clientInfoToString(user.getTokenContext().getHostAddress(),
+            //                    user.getTokenContext().getUserAgent());
+            this.loc = clientInfoToString("null", "null");
+            userid = String.valueOf(userID);
+        }else {
+            this.loc = clientInfoToString("null", "null");
+            userid = "-1";
+        }
+    }
+
+    public static AuditRecord serviceRecord(Object user, Integer status,
+            String... args) {
+        AuditRecord r = new AuditRecord(CATEGORY.SERVICE);
+        r.setArgs(Arrays.asList(args).toString());
+        r.setUserid(String.valueOf(user));
+        r.setStatus(status);
+        return r;
+    }
+
+    public static AuditRecord dbRecord(Object user, Integer status,
+            String... args) {
+        AuditRecord r = new AuditRecord(CATEGORY.DATABASE);
+        r.setArgs(Arrays.asList(args).toString());
+        r.setUserid(String.valueOf(user));
+        r.setStatus(status);
+        return r;
+    }
+
+    public AuditRecord fromJson(String json) {
+        JsonNode n = JsonUtils.readTree(json);
+        AuditRecord r = new AuditRecord();
+        r.setCategory(CATEGORY.valueOf(n.path("category").asText()));
+        r.setTarget(n.path("target").asText());
+        r.setField_1(n.path("field_1").asText());
+        r.setUserid(n.path("account").asText());
+        r.setStatus(n.path("status").asInt());
+        r.setLoc(n.path("loc").asText());
+        return r;
+    }
+
+    private String clientInfoToString(String IP, String userAgent) {
+        return userAgent + "@" + IP;
+    }
+
+    @Override
+    public String toString() {
+        return "Record{" +
+                "account='" + userid + '\'' +
+                ", category=" + category +
+                ", loc='" + loc + '\'' +
+                ", timestamp=" + timestamp +
+                ", status='" + status + '\'' +
+                ", field_1='" + field_1 + '\'' +
+                '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+
+        AuditRecord that = (AuditRecord) o;
+
+        if (userid != null ? !userid.equals(that.userid) : that.userid != null)
+            return false;
+        if (category != that.category)
+            return false;
+        if (status != null ? !status.equals(that.status) : that.status != null)
+            return false;
+        if (field_1 != null ?
+                !field_1.equals(that.field_1) :
+                that.field_1 != null)
+            return false;
+        if (loc != null ? !loc.equals(that.loc) : that.loc != null)
+            return false;
+        if (target != null ? !target.equals(that.target) : that.target != null)
+            return false;
+        if (timestamp != null ?
+                !timestamp.equals(that.timestamp) :
+                that.timestamp != null)
+            return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = userid != null ? userid.hashCode() : 0;
+        result = 31 * result + (target != null ? target.hashCode() : 0);
+        result = 31 * result + category.hashCode();
+        result = 31 * result + (loc != null ? loc.hashCode() : 0);
+        result = 31 * result + (timestamp != null ? timestamp.hashCode() : 0);
+        result = 31 * result + (status != null ? status.hashCode() : 0);
+        result = 31 * result + (field_1 != null ? field_1.hashCode() : 0);
+        return result;
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/config/BeanConfiguration.java b/src/main/java/de/ids_mannheim/korap/config/BeanConfiguration.java
new file mode 100644
index 0000000..f4b72b1
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/config/BeanConfiguration.java
@@ -0,0 +1,69 @@
+package de.ids_mannheim.korap.config;
+
+import de.ids_mannheim.korap.interfaces.AuditingIface;
+import de.ids_mannheim.korap.plugins.PluginManager;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+import org.springframework.context.support.FileSystemXmlApplicationContext;
+
+import java.net.URL;
+
+/**
+ * User: hanl
+ * Date: 10/9/13
+ * Time: 11:20 AM
+ */
+public class BeanConfiguration {
+
+    private static final String config_file = "default-config.xml";
+
+    private static ApplicationContext context = null;
+    private static PluginManager plugins;
+
+    private static void loadPlugins() {
+        plugins = new PluginManager();
+        plugins.loadPluginInterfaces();
+    }
+
+    public static void loadContext() {
+        URL url = BeanConfiguration.class.getClassLoader()
+                .getResource(config_file);
+        if (url != null && context == null)
+            context = new ClassPathXmlApplicationContext(config_file);
+    }
+
+    public static void loadContext(String filepath) {
+        if (filepath == null)
+            loadContext();
+        else {
+            if (context == null)
+                context = new FileSystemXmlApplicationContext(
+                        "file:" + filepath);
+        }
+    }
+
+    public static <T extends KustvaktConfiguration> T getConfiguration() {
+        return (T) getBean("config");
+    }
+
+    public static <T extends KustvaktConfiguration> T getConfiguration(
+            Class<T> clazz) {
+        return getBean(clazz);
+    }
+
+    public static boolean hasContext() {
+        return context != null;
+    }
+
+    protected static <T> T getBean(Class<T> clazz) {
+        return context.getBean(clazz);
+    }
+
+    protected static <T> T getBean(String name) {
+        return (T) context.getBean(name);
+    }
+
+    public static AuditingIface getAuditingProvider() {
+        return (AuditingIface) context.getBean("auditingProvider");
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/config/KustvaktClassLoader.java b/src/main/java/de/ids_mannheim/korap/config/KustvaktClassLoader.java
new file mode 100644
index 0000000..de4748e
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/config/KustvaktClassLoader.java
@@ -0,0 +1,26 @@
+package de.ids_mannheim.korap.config;
+
+import org.reflections.Reflections;
+
+import java.util.Set;
+
+/**
+ * @author hanl
+ * @date 10/06/2015
+ */
+public class KustvaktClassLoader {
+
+    private static final Reflections reflections = new Reflections(
+            "de.ids_mannheim.korap");
+
+    /**
+     * loads interface implementations in current classpath
+     *
+     * @param iface
+     * @param <T>
+     * @return
+     */
+    public static <T> Set<Class<? extends T>> load(Class<T> iface) {
+        return reflections.getSubTypesOf(iface);
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/config/KustvaktConfiguration.java b/src/main/java/de/ids_mannheim/korap/config/KustvaktConfiguration.java
new file mode 100644
index 0000000..52ac3c7
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/config/KustvaktConfiguration.java
@@ -0,0 +1,116 @@
+package de.ids_mannheim.korap.config;
+
+import de.ids_mannheim.korap.utils.KorAPLogger;
+import lombok.Getter;
+import org.apache.log4j.PropertyConfigurator;
+import org.slf4j.Logger;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * if configuration class is extended, load method should be overriden
+ * @author hanl
+ * @date 05/02/2014
+ */
+
+@Getter
+public class KustvaktConfiguration {
+
+    private final Logger jlog = KorAPLogger
+            .initiate(KustvaktConfiguration.class);
+
+    // deprec?!
+    private final BACKENDS DEFAULT_ENGINE = BACKENDS.LUCENE;
+    private int maxhits;
+
+    private int port;
+    private int returnhits;
+    private String serverHost;
+    private String indexDir;
+
+    private List<String> queryLanguages;
+    private String host;
+
+    private URL issuer;
+
+    /**
+     * loading of the properties and mapping to parameter variables
+     *
+     * @param korap
+     * @return
+     */
+    protected Properties load(Properties korap) {
+        String log4jconfig = korap
+                .getProperty("log4jconfig", "log4j.properties");
+        loadLog4jLogger(log4jconfig);
+        maxhits = new Integer(korap.getProperty("maxhits", "50000"));
+        returnhits = new Integer(korap.getProperty("returnhits", "50000"));
+        indexDir = korap.getProperty("lucene.indexDir", "");
+        port = new Integer(korap.getProperty("server.port", "8080"));
+        // server options
+        serverHost = String
+                .valueOf(korap.getProperty("server.host", "localhost"));
+        String queries = korap.getProperty("korap.ql", "");
+        String[] qls = queries.split(",");
+        queryLanguages = new ArrayList<>();
+        for (String querylang : qls)
+            queryLanguages.add(querylang.trim().toUpperCase());
+        //        issuer = new URL(korap.getProperty("korap.issuer", ""));
+        return korap;
+    }
+
+    public void setProperties(Properties props) {
+        this.load(props);
+    }
+
+    public BACKENDS chooseBackend(String value) {
+        if (value == null || value.equals("null"))
+            return DEFAULT_ENGINE;
+        else
+            return Enum.valueOf(BACKENDS.class, value.toUpperCase());
+    }
+
+    private void loadLog4jLogger(String log4jconfig) {
+        /** load log4j configuration file programmatically */
+        Properties log4j = new Properties();
+        try {
+            if (!log4jconfig.equals("")) {
+                log4j.load(new FileInputStream(log4jconfig));
+                PropertyConfigurator.configure(log4j);
+                jlog.info(
+                        "using local logging properties file ({}) to configure logging system",
+                        log4jconfig);
+            }else
+                loadClassLogger();
+        }catch (Exception e) {
+            loadClassLogger();
+        }
+    }
+
+    public void loadClassLogger() {
+        Properties log4j = new Properties();
+        jlog.info(
+                "using class path logging properties file to configure logging system");
+
+        try {
+            log4j.load(KustvaktConfiguration.class.getClassLoader()
+                    .getResourceAsStream("log4j.properties"));
+        }catch (IOException e) {
+            // do nothing
+        }
+
+        PropertyConfigurator.configure(log4j);
+        jlog.warn(
+                "No logger properties detected. Using default logger properties");
+    }
+
+    public enum BACKENDS {
+        NEO4J, LUCENE
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/exceptions/BaseException.java b/src/main/java/de/ids_mannheim/korap/exceptions/BaseException.java
new file mode 100644
index 0000000..408f591
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/exceptions/BaseException.java
@@ -0,0 +1,47 @@
+package de.ids_mannheim.korap.exceptions;
+
+import de.ids_mannheim.korap.auditing.AuditRecord;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author hanl
+ * @date 29/01/2014
+ */
+@Getter
+public abstract class BaseException extends Exception {
+
+    protected List<AuditRecord> records = new ArrayList<>();
+    private Integer statusCode;
+    private String entity;
+
+
+    public BaseException(int code) {
+        this.statusCode = code;
+    }
+
+    public BaseException(int status, String message, String entity) {
+        super(message);
+        this.statusCode = status;
+        this.entity = entity;
+    }
+
+    public BaseException(int status, String entity) {
+        this(status);
+        this.entity = entity;
+    }
+
+    public BaseException(Throwable cause, int status) {
+        super(cause);
+        this.statusCode = status;
+
+    }
+
+    public BaseException(String message, Throwable cause, int status) {
+        super(message, cause);
+        this.statusCode = status;
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/exceptions/EmptyResultException.java b/src/main/java/de/ids_mannheim/korap/exceptions/EmptyResultException.java
new file mode 100644
index 0000000..5541695
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/exceptions/EmptyResultException.java
@@ -0,0 +1,13 @@
+package de.ids_mannheim.korap.exceptions;
+
+/**
+ * @author hanl
+ * @date 25/03/2014
+ */
+public class EmptyResultException extends BaseException {
+
+    public EmptyResultException(String entity) {
+        super(StatusCodes.EMPTY_RESULTS, entity);
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/exceptions/KorAPException.java b/src/main/java/de/ids_mannheim/korap/exceptions/KorAPException.java
new file mode 100644
index 0000000..a050770
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/exceptions/KorAPException.java
@@ -0,0 +1,52 @@
+package de.ids_mannheim.korap.exceptions;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @author hanl
+ * @date 11/12/2013
+ */
+@Setter
+@Getter
+public class KorAPException extends BaseException {
+
+    private String userid;
+
+    public KorAPException(Integer status) {
+        super(status);
+    }
+
+    public KorAPException(Object userid, Integer status) {
+        this(status);
+        this.userid = String.valueOf(userid);
+    }
+
+    public KorAPException(Object userid, Integer status, String message,
+            String entity) {
+        super(status, message, entity);
+        this.userid = String.valueOf(userid);
+    }
+
+    public KorAPException(Integer status, String message, String entity) {
+        super(status, message, entity);
+    }
+
+    public KorAPException(Throwable cause, Integer status) {
+        super(cause, status);
+    }
+
+    public KorAPException(String message, Throwable cause, Integer status) {
+        super(message, cause, status);
+    }
+
+    @Override
+    public String toString() {
+        return "Excpt{" +
+                "status=" + getStatusCode() +
+                ", message=" + getMessage() +
+                ", args=" + getEntity() +
+                ", userid=" + userid +
+                '}';
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/exceptions/Message.java b/src/main/java/de/ids_mannheim/korap/exceptions/Message.java
new file mode 100644
index 0000000..f9021b4
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/exceptions/Message.java
@@ -0,0 +1,109 @@
+package de.ids_mannheim.korap.exceptions;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+
+/**
+ * @author hanl
+ * @date 03/12/2014
+ */
+public class Message implements Cloneable {
+
+    ObjectMapper mapper = new ObjectMapper();
+    private String msg;
+    private int code = 0;
+    private LinkedList<String> parameters;
+
+    public Message(int code, String msg) {
+        this.code = code;
+        this.msg = msg;
+    }
+
+    public Message() {
+    }
+
+    @JsonIgnore
+    public Message setMessage(String msg) {
+        this.msg = msg;
+        return this;
+    }
+
+    @JsonIgnore
+    public String getMessage() {
+        return this.msg;
+    }
+
+    @JsonIgnore
+    public Message setCode(int code) {
+        this.code = code;
+        return this;
+    }
+
+    @JsonIgnore
+    public int getCode() {
+        return this.code;
+    }
+
+    public Message addParameter(String param) {
+        if (this.parameters == null) {
+            this.parameters = new LinkedList();
+        }
+
+        this.parameters.add(param);
+        return this;
+    }
+
+    public Object clone() throws CloneNotSupportedException {
+        Message clone = new Message();
+        if (this.msg != null) {
+            clone.msg = this.msg;
+        }
+
+        clone.code = this.code;
+        if (this.parameters != null) {
+            Iterator i$ = this.parameters.iterator();
+
+            while (i$.hasNext()) {
+                String p = (String) i$.next();
+                clone.addParameter(p);
+            }
+        }
+
+        return clone;
+    }
+
+    public JsonNode toJSONnode() {
+        ArrayNode message = this.mapper.createArrayNode();
+        if (this.code != 0) {
+            message.add(this.getCode());
+        }
+
+        message.add(this.getMessage());
+        if (this.parameters != null) {
+            Iterator i$ = this.parameters.iterator();
+
+            while (i$.hasNext()) {
+                String p = (String) i$.next();
+                message.add(p);
+            }
+        }
+
+        return message;
+    }
+
+    public String toJSON() {
+        String msg = "";
+
+        try {
+            return this.mapper.writeValueAsString(this.toJSONnode());
+        } catch (Exception var3) {
+            msg = ", \"" + var3.getLocalizedMessage() + "\"";
+            return "[620, \"Unable to generate JSON\"" + msg + "]";
+        }
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/exceptions/Messages.java b/src/main/java/de/ids_mannheim/korap/exceptions/Messages.java
new file mode 100644
index 0000000..0729448
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/exceptions/Messages.java
@@ -0,0 +1,167 @@
+package de.ids_mannheim.korap.exceptions;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import de.ids_mannheim.korap.utils.JsonUtils;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * @author hanl
+ * @date 03/12/2014
+ */
+public class Messages implements Cloneable, Iterable<Message> {
+
+    private ArrayList<Message> messages = new ArrayList(3);
+
+    public Messages() {
+    }
+
+    public Iterator<Message> iterator() {
+        return new Messages.MessageIterator();
+    }
+
+    public Message add(int code, String message, String... terms) {
+        Message newMsg = new Message(code, message);
+        this.messages.add(newMsg);
+        if (terms != null) {
+            String[] arr$ = terms;
+            int len$ = terms.length;
+
+            for (int i$ = 0; i$ < len$; ++i$) {
+                String t = arr$[i$];
+                newMsg.addParameter(t);
+            }
+        }
+
+        return newMsg;
+    }
+
+    public Message add(Message msg) {
+        try {
+            Message e = (Message) msg.clone();
+            this.messages.add(e);
+            return e;
+        } catch (CloneNotSupportedException var3) {
+            return (Message) null;
+        }
+    }
+
+    public Message add(JsonNode msg) throws KorAPException {
+        if (msg.isArray() && msg.has(0)) {
+            Message newMsg = new Message();
+            short i = 1;
+            if (msg.get(0).isNumber()) {
+                newMsg.setCode(msg.get(0).asInt());
+                if (!msg.has(1)) {
+                    throw new KorAPException(750, "Passed notifications are not well formed", null);
+                }
+
+                newMsg.setMessage(msg.get(1).asText());
+                ++i;
+            } else {
+                newMsg.setMessage(msg.get(0).asText());
+            }
+
+            while (msg.has(i)) {
+                newMsg.addParameter(msg.get(i++).asText());
+            }
+
+            this.add((Message) newMsg);
+            return newMsg;
+        } else {
+            throw new KorAPException(750, "Passed notifications are not well formed", null);
+        }
+    }
+
+    public Messages add(Messages msgs) {
+        try {
+            Iterator e = msgs.getMessages().iterator();
+
+            while (e.hasNext()) {
+                Message msg = (Message) e.next();
+                this.add((Message) ((Message) msg.clone()));
+            }
+        } catch (CloneNotSupportedException var4) {
+            ;
+        }
+
+        return this;
+    }
+
+    public Messages clear() {
+        this.messages.clear();
+        return this;
+    }
+
+    public int size() {
+        return this.messages.size();
+    }
+
+    @JsonIgnore
+    public Message get(int index) {
+        return index >= this.size() ? (Message) null : (Message) this.messages.get(index);
+    }
+
+    @JsonIgnore
+    public List<Message> getMessages() {
+        return this.messages;
+    }
+
+    public Object clone() throws CloneNotSupportedException {
+        Messages clone = new Messages();
+        Iterator i$ = this.messages.iterator();
+
+        while (i$.hasNext()) {
+            Message m = (Message) i$.next();
+            clone.add((Message) ((Message) m.clone()));
+        }
+
+        return clone;
+    }
+
+    public JsonNode toJSONnode() {
+        ArrayNode messageArray = JsonUtils.createArrayNode();
+        Iterator i$ = this.messages.iterator();
+
+        while (i$.hasNext()) {
+            Message msg = (Message) i$.next();
+            messageArray.add(msg.toJSONnode());
+        }
+
+        return messageArray;
+    }
+
+    public String toJSON() {
+        String msg = "";
+
+        try {
+            return JsonUtils.toJSON(this.toJSONnode());
+        } catch (Exception var3) {
+            msg = ", \"" + var3.getLocalizedMessage() + "\"";
+            return "[620, \"Unable to generate JSON\"" + msg + "]";
+        }
+    }
+
+    private class MessageIterator implements Iterator<Message> {
+        int index = 0;
+
+        public MessageIterator() {
+        }
+
+        public boolean hasNext() {
+            return this.index < Messages.this.messages.size();
+        }
+
+        public Message next() {
+            return (Message) Messages.this.messages.get(this.index++);
+        }
+
+        public void remove() {
+            Messages.this.messages.remove(this.index);
+        }
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/exceptions/NotAuthorizedException.java b/src/main/java/de/ids_mannheim/korap/exceptions/NotAuthorizedException.java
new file mode 100644
index 0000000..2b499c7
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/exceptions/NotAuthorizedException.java
@@ -0,0 +1,33 @@
+package de.ids_mannheim.korap.exceptions;
+
+import lombok.Data;
+
+/**
+ * @author hanl
+ * @date 11/12/2013
+ */
+// a security table registers all these exceptions (failed authentication, failed access to a resource, etc.)
+@Data
+@Deprecated
+public class NotAuthorizedException extends BaseException {
+
+    public NotAuthorizedException(int status) {
+        super(status);
+    }
+
+    public NotAuthorizedException(int status, String entity) {
+        super(status, "", entity);
+    }
+
+    public NotAuthorizedException(int status, String message, String entity) {
+        super(status, message, entity);
+    }
+
+    public NotAuthorizedException(Throwable cause, int status) {
+        super(cause, status);
+    }
+
+    public NotAuthorizedException(String message, Throwable cause, int status) {
+        super(message, cause, status);
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/exceptions/StatusCodes.java b/src/main/java/de/ids_mannheim/korap/exceptions/StatusCodes.java
new file mode 100644
index 0000000..6db7b0e
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/exceptions/StatusCodes.java
@@ -0,0 +1,103 @@
+package de.ids_mannheim.korap.exceptions;
+
+/**
+ * @author hanl
+ * @date 07/09/2014
+ */
+public class StatusCodes {
+
+    /**
+     * 100 status codes for standard system errors
+     */
+    public static final Integer EMPTY_RESULTS = 100;
+    public static final Integer REQUEST_INVALID = 101;
+    //fixme: redundancy?!
+    public static final Integer ENTRY_EXISTS = 102;
+    public static final Integer STATUS_OK = 103;
+    public static final Integer UNSUPPORTED_OPERATION = 104;
+    public static final Integer ILLEGAL_ARGUMENT = 105;
+    public static final Integer CONNECTION_ERROR = 106;
+    public static final Integer NOTHING_CHANGED = 107;
+    public static final Integer PARAMETER_VALIDATION_ERROR = 108;
+    public static final Integer DEFAULT_ERROR = 109;
+    public static final Integer NOT_SUPPORTED = 110;
+
+    /**
+     * 400 status codes for account/authentication relevant components
+     */
+
+    public static final Integer ACCOUNT_DEACTIVATED = 200;
+    public static final Integer ACCOUNT_CONFIRMATION_FAILED = 201;
+    public static final Integer ALREADY_LOGGED_IN = 202;
+    public static final Integer EXPIRED = 204;
+    public static final Integer BAD_CREDENTIALS = 205;
+    public static final Integer UNCONFIRMED_ACCOUNT = 206;
+    public static final Integer NAME_EXISTS = 207;
+    public static final Integer PASSWORD_RESET_FAILED = 208;
+    // fixme: ?!
+    public static final Integer AUTHENTICATION_DENIED = 209;
+
+    public static final Integer LOGIN_SUCCESSFUL = 210;
+    public static final Integer LOGIN_FAILED = 211;
+    public static final Integer LOGOUT_SUCCESSFUL = 212;
+    public static final Integer LOGOUT_FAILED = 213;
+
+    public static final Integer CLIENT_REGISTRATION_FAILURE = 214;
+    public static final Integer CLIENT_REMOVAL_FAILURE = 215;
+    public static final Integer CLIENT_AUTHORIZATION_FAILURE = 216;
+
+
+    /**
+     * 500 status codes for access control related components (also policy rewrite)
+     */
+    public static final Integer PERMISSION_DENIED = 401;
+    public static final Integer UNSUPPORTED_RESOURCE = 402;
+    public static final Integer UNSUPPORTED_FOUNDRY = 403;
+    public static final Integer UNSUPPORTED_CORPUS = 404;
+    public static final Integer UNSUPPORTED_LAYER = 405;
+    // make a distinction between no and invalid vc?
+    public static final Integer UNSUPPORTED_VIRTUALCOLLECTION = 406;
+    public static final Integer CORPUS_REWRITE = 407;
+    public static final Integer FOUNDRY_REWRITE = 408;
+    public static final Integer FOUNDRY_INJECTION = 409;
+    public static final Integer MISSING_ARGUMENTS = 410;
+    public static final Integer MISSING_VIRTUALCOLLECTION = 411;
+    public static final Integer MISSING_POLICY_TARGET = 412;
+    public static final Integer MISSING_POLICY_CONDITIONS = 413;
+    public static final Integer MISSING_POLICY_PERMISSION = 414;
+
+    // todo: extend according to policy rewrite possible!
+    // policy errors
+    public static final Integer POLICY_ERROR_DEFAULT = 500;
+    public static final Integer POLICY_CREATE_ERROR = 501;
+    public static final Integer NO_POLICIES = 502;
+
+    // database codes
+    public static final Integer DB_GET_FAILED = 601;
+    public static final Integer DB_INSERT_FAILED = 602;
+    public static final Integer DB_DELETE_FAILED = 603;
+    public static final Integer DB_UPDATE_FAILED = 604;
+
+    public static final Integer DB_GET_SUCCESSFUL = 605;
+    public static final Integer DB_INSERT_SUCCESSFUL = 606;
+    public static final Integer DB_DELETE_SUCCESSFUL = 607;
+    public static final Integer DB_UPDATE_SUCCESSFUL = 608;
+
+    // service status codes
+    public static final Integer CREATE_ACCOUNT_SUCCESSFUL = 700;
+    public static final Integer CREATE_ACCOUNT_FAILED = 701;
+    public static final Integer DELETE_ACCOUNT_SUCCESSFUL = 702;
+    public static final Integer DELETE_ACCOUNT_FAILED = 703;
+    public static final Integer UPDATE_ACCOUNT_SUCCESSFUL = 704;
+    public static final Integer UPDATE_ACCOUNT_FAILED = 705;
+
+    public static final Integer GET_ACCOUNT_SUCCESSFUL = 706;
+    public static final Integer GET_ACCOUNT_FAILED = 707;
+
+    /**
+     * 300 status codes for query language and serialization
+     */
+
+    public static final Integer NO_QUERY = 301;
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/exceptions/WrappedException.java b/src/main/java/de/ids_mannheim/korap/exceptions/WrappedException.java
new file mode 100644
index 0000000..c180f1b
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/exceptions/WrappedException.java
@@ -0,0 +1,35 @@
+package de.ids_mannheim.korap.exceptions;
+
+import de.ids_mannheim.korap.auditing.AuditRecord;
+
+import java.util.Arrays;
+
+/**
+ * @author hanl
+ * @date 08/04/2015
+ */
+// should be a http exception that responds to a service point
+// is the extension of the notauthorized exception!
+public class WrappedException extends KorAPException {
+
+    private WrappedException(Object userid, Integer status, String message,
+            String args) {
+        super(String.valueOf(userid), status, message, args);
+    }
+
+    public WrappedException(Object userid, Integer status, String... args) {
+        this(userid, status, "", Arrays.asList(args).toString());
+        AuditRecord record = AuditRecord.serviceRecord(userid, status, args);
+        this.records.add(record);
+    }
+
+    public WrappedException(KorAPException e, Integer status, String... args) {
+        this(e.getUserid(), e.getStatusCode(), e.getMessage(), e.getEntity());
+        AuditRecord record = AuditRecord
+                .serviceRecord(e.getUserid(), status, args);
+        record.setField_1(e.toString());
+        this.records.addAll(e.getRecords());
+        this.records.add(record);
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/exceptions/dbException.java b/src/main/java/de/ids_mannheim/korap/exceptions/dbException.java
new file mode 100644
index 0000000..d505e13
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/exceptions/dbException.java
@@ -0,0 +1,48 @@
+package de.ids_mannheim.korap.exceptions;
+
+import de.ids_mannheim.korap.auditing.AuditRecord;
+
+import java.util.Arrays;
+
+/**
+ * @author hanl
+ * @date 08/04/2015
+ */
+public class dbException extends KorAPException {
+
+    private dbException(Object userid, Integer status, String message,
+            String args) {
+        super(String.valueOf(userid), status, message, args);
+    }
+
+    public dbException(Object userid, String target, Integer status,
+            String... args) {
+        this(userid, status, "",
+                Arrays.asList(args).toString());
+        AuditRecord record = new AuditRecord(AuditRecord.CATEGORY.DATABASE);
+        record.setUserid(String.valueOf(userid));
+        record.setStatus(status);
+        record.setTarget(target);
+        record.setArgs(this.getEntity());
+        this.records.add(record);
+    }
+
+    public dbException(KorAPException e, Integer status, String... args) {
+        this(e.getUserid(), e.getStatusCode(), e.getMessage(), e.getEntity());
+        AuditRecord record = AuditRecord
+                .dbRecord(e.getUserid(), status, args);
+        record.setField_1(e.toString());
+        this.records.addAll(e.getRecords());
+        this.records.add(record);
+    }
+
+    @Override
+    public String toString() {
+        return "DBExcpt{" +
+                "status=" + getStatusCode() +
+                ", message=" + getMessage() +
+                ", args=" + getEntity() +
+                ", userid=" + this.getUserid() +
+                '}';
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/interfaces/AuditingIface.java b/src/main/java/de/ids_mannheim/korap/interfaces/AuditingIface.java
new file mode 100644
index 0000000..82bdd55
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/interfaces/AuditingIface.java
@@ -0,0 +1,56 @@
+package de.ids_mannheim.korap.interfaces;
+
+import de.ids_mannheim.korap.auditing.AuditRecord;
+import de.ids_mannheim.korap.user.User;
+import org.joda.time.DateTime;
+import org.joda.time.LocalDate;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * User: hanl
+ * Date: 8/20/13
+ * Time: 10:45 AM
+ */
+//fixme: move table to different database!
+public abstract class AuditingIface implements Runnable {
+
+    protected static int BATCH_SIZE = 15;
+    protected final List<AuditRecord> records = new ArrayList<>(BATCH_SIZE + 5);
+    private final List<AuditRecord> buffer = new ArrayList<>(BATCH_SIZE + 5);
+
+    public abstract <T extends AuditRecord> List<T> retrieveRecords(
+            AuditRecord.CATEGORY category, DateTime day, DateTime until,
+            boolean exact, int limit);
+
+    public abstract <T extends AuditRecord> List<T> retrieveRecords(
+            AuditRecord.CATEGORY category, User user, int limit);
+
+    public abstract <T extends AuditRecord> List<T> retrieveRecords(
+            LocalDate day, int hitMax);
+
+    public abstract <T extends AuditRecord> List<T> retrieveRecords(
+            String userID, LocalDate start, LocalDate end, int hitMax);
+
+    private void addAndRun(AuditRecord record) {
+        if (buffer.size() > BATCH_SIZE) {
+            records.clear();
+            records.addAll(buffer);
+            run();
+            buffer.clear();
+        }
+        if (buffer.size() <= BATCH_SIZE)
+            buffer.add(record);
+    }
+
+    public <T extends AuditRecord> void audit(T request) {
+        addAndRun(request);
+    }
+
+    public <T extends AuditRecord> void audit(List<T> requests) {
+        for (T rec : requests)
+            addAndRun(rec);
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/interfaces/AuthenticationIface.java b/src/main/java/de/ids_mannheim/korap/interfaces/AuthenticationIface.java
new file mode 100644
index 0000000..e02933e
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/interfaces/AuthenticationIface.java
@@ -0,0 +1,25 @@
+package de.ids_mannheim.korap.interfaces;
+
+import de.ids_mannheim.korap.exceptions.KorAPException;
+import de.ids_mannheim.korap.ext.security.AccessLevel;
+import de.ids_mannheim.korap.user.TokenContext;
+import de.ids_mannheim.korap.user.User;
+
+import java.util.Map;
+
+public abstract class AuthenticationIface {
+
+    public abstract TokenContext getUserStatus(String authToken)
+            throws KorAPException;
+
+    public abstract TokenContext createUserSession(User user,
+            Map<String, Object> attr) throws KorAPException;
+
+    public abstract void removeUserSession(String token) throws KorAPException;
+
+    public abstract AccessLevel[] retrieveLevelAccess(String authToken)
+            throws KorAPException;
+
+    public abstract String getIdentifier();
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/interfaces/EncryptionIface.java b/src/main/java/de/ids_mannheim/korap/interfaces/EncryptionIface.java
new file mode 100644
index 0000000..0b00b31
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/interfaces/EncryptionIface.java
@@ -0,0 +1,78 @@
+package de.ids_mannheim.korap.interfaces;
+
+import de.ids_mannheim.korap.exceptions.KorAPException;
+import de.ids_mannheim.korap.user.User;
+
+import java.io.UnsupportedEncodingException;
+import java.security.NoSuchAlgorithmException;
+import java.util.Map;
+
+public interface EncryptionIface {
+
+    public enum Encryption {
+        SIMPLE, ESAPICYPHER, BCRYPT
+    }
+
+    /**
+     * One-way hashing of String input. Used to canonicalize
+     *
+     * @param input
+     * @param salt
+     * @return
+     * @throws java.security.NoSuchAlgorithmException
+     * @throws java.io.UnsupportedEncodingException
+     */
+    public String produceSecureHash(String input, String salt)
+            throws NoSuchAlgorithmException, UnsupportedEncodingException,
+            KorAPException;
+
+    public String produceSecureHash(String input)
+            throws NoSuchAlgorithmException, UnsupportedEncodingException,
+            KorAPException;
+
+    public String hash(String value);
+
+    /**
+     * @param plain
+     * @param hash
+     * @param salt
+     * @return
+     */
+    public boolean checkHash(String plain, String hash, String salt);
+
+    public boolean checkHash(String plain, String hash);
+
+    public String getSalt(User user);
+
+    /**
+     * create random String to be used as authentication token
+     *
+     * @return
+     */
+    public String createToken(boolean hash, Object... obj);
+
+    public String createToken();
+
+    /**
+     * create a random Integer to be used as ID for databases
+     *
+     * @return
+     */
+    public String createID(Object... obj);
+
+    public String encodeBase();
+
+    public String validateIPAddress(String ipaddress) throws KorAPException;
+
+    public String validateEmail(String email) throws KorAPException;
+
+    public Map<String, Object> validateMap(Map<String, Object> map)
+            throws KorAPException;
+
+    public String validateString(String input) throws KorAPException;
+
+    public void validate(Object instance) throws KorAPException;
+
+    public String validatePassphrase(String pw) throws KorAPException;
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/interfaces/EntityHandlerIface.java b/src/main/java/de/ids_mannheim/korap/interfaces/EntityHandlerIface.java
new file mode 100644
index 0000000..01cab35
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/interfaces/EntityHandlerIface.java
@@ -0,0 +1,44 @@
+package de.ids_mannheim.korap.interfaces;
+
+import de.ids_mannheim.korap.exceptions.EmptyResultException;
+import de.ids_mannheim.korap.exceptions.KorAPException;
+import de.ids_mannheim.korap.user.User;
+import de.ids_mannheim.korap.user.UserDetails;
+import de.ids_mannheim.korap.user.UserSettings;
+
+/**
+ * User: hanl
+ * Date: 8/19/13
+ * Time: 11:04 AM
+ */
+public interface EntityHandlerIface {
+    public UserSettings getUserSettings(Integer userid) throws KorAPException;
+
+    public int updateSettings(UserSettings settings) throws KorAPException;
+
+    public UserDetails getUserDetails(Integer userid) throws KorAPException;
+
+    public int updateUserDetails(UserDetails details) throws KorAPException;
+
+    //    public List<UserQuery> getUserQueries(User user) throws KorAPException;
+
+    //    public UserQuery getUserQuery(String id) throws KorAPException;
+
+    //    public void updateUserQueries(User user, List<UserQuery> newOnes) throws KorAPException;
+
+    public User getAccount(String username) throws
+            EmptyResultException, KorAPException;
+
+    public int updateAccount(User user) throws KorAPException;
+
+    public int createAccount(User user) throws KorAPException;
+
+    public int deleteAccount(Integer userid) throws KorAPException;
+
+    public int resetPassphrase(String username, String uriToken,
+            String passphrase) throws KorAPException;
+
+    public int activateAccount(String username, String uriToken)
+            throws KorAPException;
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/interfaces/UserControllerIface.java b/src/main/java/de/ids_mannheim/korap/interfaces/UserControllerIface.java
new file mode 100644
index 0000000..67d6545
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/interfaces/UserControllerIface.java
@@ -0,0 +1,59 @@
+package de.ids_mannheim.korap.interfaces;
+
+import de.ids_mannheim.korap.exceptions.KorAPException;
+import de.ids_mannheim.korap.user.*;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author hanl
+ * @date 15/06/2015
+ */
+public abstract class UserControllerIface {
+
+    private Map<String, AuthenticationIface> providers;
+
+    //todo: test if constr actually called
+    public UserControllerIface() {
+        this.providers = new HashMap<>();
+    }
+
+    public void setProviders(Set<AuthenticationIface> providers) {
+        for (AuthenticationIface i : providers)
+            this.providers.put(i.getIdentifier(), i);
+    }
+
+    protected AuthenticationIface getProvider(String key) {
+        AuthenticationIface iface;
+        if (key == null)
+            iface = this.providers.get(Attributes.API_AUTHENTICATION);
+        else
+            iface = this.providers.get(key.toUpperCase());
+        return iface;
+    }
+
+    public abstract User authenticate(int type, String username,
+            String password, Map<String, Object> attributes)
+            throws KorAPException;
+
+    public abstract void logout(TokenContext context) throws KorAPException;
+
+    public abstract void lockAccount(User user) throws KorAPException;
+
+    public abstract boolean updateAccount(User user) throws KorAPException;
+
+    public abstract boolean deleteAccount(User user) throws KorAPException;
+
+    public abstract UserDetails getUserDetails(User user) throws KorAPException;
+
+    public abstract UserSettings getUserSettings(User user)
+            throws KorAPException;
+
+    public abstract void updateUserDetails(User user, UserDetails details)
+            throws KorAPException;
+
+    public abstract void updateUserSettings(User user, UserSettings settings)
+            throws KorAPException;
+}
diff --git a/src/main/java/de/ids_mannheim/korap/interfaces/defaults/DefaultAuditing.java b/src/main/java/de/ids_mannheim/korap/interfaces/defaults/DefaultAuditing.java
new file mode 100644
index 0000000..cb0eef7
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/interfaces/defaults/DefaultAuditing.java
@@ -0,0 +1,50 @@
+package de.ids_mannheim.korap.interfaces.defaults;
+
+import de.ids_mannheim.korap.auditing.AuditRecord;
+import de.ids_mannheim.korap.interfaces.AuditingIface;
+import de.ids_mannheim.korap.user.User;
+import org.joda.time.DateTime;
+import org.joda.time.LocalDate;
+
+import java.util.List;
+
+/**
+ * @author hanl
+ * @date 05/06/2015
+ */
+public class DefaultAuditing extends AuditingIface {
+
+    public DefaultAuditing() {
+
+    }
+
+    @Override
+    public <T extends AuditRecord> List<T> retrieveRecords(
+            AuditRecord.CATEGORY category, DateTime day, DateTime until,
+            boolean exact, int limit) {
+        return null;
+    }
+
+    @Override
+    public <T extends AuditRecord> List<T> retrieveRecords(
+            AuditRecord.CATEGORY category, User user, int limit) {
+        return null;
+    }
+
+    @Override
+    public <T extends AuditRecord> List<T> retrieveRecords(LocalDate day,
+            int hitMax) {
+        return null;
+    }
+
+    @Override
+    public <T extends AuditRecord> List<T> retrieveRecords(String userID,
+            LocalDate start, LocalDate end, int hitMax) {
+        return null;
+    }
+
+    @Override
+    public void run() {
+        //todo: append to logging file or other auditing file
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/interfaces/defaults/DefaultEncryption.java b/src/main/java/de/ids_mannheim/korap/interfaces/defaults/DefaultEncryption.java
new file mode 100644
index 0000000..8c787db
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/interfaces/defaults/DefaultEncryption.java
@@ -0,0 +1,110 @@
+package de.ids_mannheim.korap.interfaces.defaults;
+
+import de.ids_mannheim.korap.exceptions.KorAPException;
+import de.ids_mannheim.korap.interfaces.EncryptionIface;
+import de.ids_mannheim.korap.user.User;
+
+import java.io.UnsupportedEncodingException;
+import java.math.BigInteger;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Map;
+
+/**
+ * @author hanl
+ * @date 05/06/2015
+ */
+public class DefaultEncryption implements EncryptionIface {
+
+    private SecureRandom randomizer;
+
+    public DefaultEncryption() {
+        randomizer = new SecureRandom();
+    }
+
+    @Override
+    public String produceSecureHash(String input, String salt)
+            throws NoSuchAlgorithmException, UnsupportedEncodingException,
+            KorAPException {
+        return null;
+    }
+
+    @Override
+    public String produceSecureHash(String input)
+            throws NoSuchAlgorithmException, UnsupportedEncodingException,
+            KorAPException {
+        return null;
+    }
+
+    @Override
+    public String hash(String value) {
+        return null;
+    }
+
+    @Override
+    public boolean checkHash(String plain, String hash, String salt) {
+        return false;
+    }
+
+    @Override
+    public boolean checkHash(String plain, String hash) {
+        return false;
+    }
+
+    @Override
+    public String getSalt(User user) {
+        return null;
+    }
+
+    @Override
+    public String createToken(boolean hash, Object... obj) {
+        return createToken();
+
+    }
+
+    @Override
+    public String createToken() {
+        return new BigInteger(100, randomizer).toString(20);
+    }
+
+    @Override
+    public String createID(Object... obj) {
+        return createToken();
+    }
+
+    @Override
+    public String encodeBase() {
+        return null;
+    }
+
+    @Override
+    public String validateIPAddress(String ipaddress) throws KorAPException {
+        return null;
+    }
+
+    @Override
+    public String validateEmail(String email) throws KorAPException {
+        return null;
+    }
+
+    @Override
+    public Map<String, Object> validateMap(Map<String, Object> map)
+            throws KorAPException {
+        return null;
+    }
+
+    @Override
+    public String validateString(String input) throws KorAPException {
+        return null;
+    }
+
+    @Override
+    public void validate(Object instance) throws KorAPException {
+
+    }
+
+    @Override
+    public String validatePassphrase(String pw) throws KorAPException {
+        return null;
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/plugins/PluginManager.java b/src/main/java/de/ids_mannheim/korap/plugins/PluginManager.java
new file mode 100644
index 0000000..262985f
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/plugins/PluginManager.java
@@ -0,0 +1,31 @@
+package de.ids_mannheim.korap.plugins;
+
+import de.ids_mannheim.korap.interfaces.EntityHandlerIface;
+import de.ids_mannheim.korap.interfaces.UserControllerIface;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author hanl
+ * @date 15/06/2015
+ */
+// via spring a list of implementations is inserted, for which there will be default constructors loaded
+public class PluginManager {
+
+    private Map<String, Class> plugins;
+
+    public PluginManager() {
+        plugins = new HashMap<>();
+    }
+
+    public void loadPluginInterfaces() {
+        plugins.put("userdb", EntityHandlerIface.class);
+        plugins.put("usercontroller", UserControllerIface.class);
+        plugins.put("encrytion", EntityHandlerIface.class);
+    }
+
+    public void register(String key, Class cl) {
+        plugins.put(key, cl);
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/user/Attributes.java b/src/main/java/de/ids_mannheim/korap/user/Attributes.java
new file mode 100644
index 0000000..0bba5b7
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/user/Attributes.java
@@ -0,0 +1,143 @@
+package de.ids_mannheim.korap.user;
+
+public class Attributes {
+
+    public static final String AUTHORIZATION = "Authorization";
+    public static final String SESSION_AUTHENTICATION = "session_token";
+    public static final String API_AUTHENTICATION = "api_token";
+    public static final String OAUTH2_AUTHORIZATION = "bearer";
+    public static final String OPENID_AUTHENTICATION = "id_token";
+    public static final String BASIC_AUTHENTICATION = "basic";
+
+    public static final String CLIENT_ID = "client_id";
+    public static final String CLIENT_SECRET = "client_secret";
+    public static final String SCOPES = "scopes";
+
+    public static final String SERVICE_ACCESS = "service_access";
+    public static final String USER = "KorapUser";
+    public static final String SHIBUSER = "ShibUser";
+    public static final String DEMO_DISPLAY = "Anonymous";
+    public static final String DEMOUSER_PASSWORD = "demo";
+
+    public static final String SETTINGS = "LocalSettings";
+    //    public static final String STORAGE_SETTINGS = "StorageSettings";
+
+    public static final String QUERY_ABBREVIATION = "Q";
+    public static final String LAYER = "layer";
+
+    public static final String TYPE = "type";
+
+    public static final String UID = "accountID";
+    public static final String USERNAME = "username";
+    public static final String PASSWORD = "password";
+    public static final String GENDER = "gender";
+    public static final String FIRSTNAME = "firstName";
+    public static final String LASTNAME = "lastName";
+    public static final String PHONE = "phone";
+    public static final String INSTITUTION = "institution";
+    public static final String EMAIL = "email";
+    public static final String ADDRESS = "address";
+    public static final String COUNTRY = "country";
+    public static final String ACCOUNT_CREATION = "accountCreation";
+    public static final String ACCOUNTLOCK = "accountLock";
+    public static final String ACCOUNTLINK = "accountLink";
+    public static final String URI = "uri";
+    public static final String URI_FRAGMENT = "URIFragment";
+    public static final String URI_EXPIRATION = "uriExpiration";
+    public static final String PRIVATE_USAGE = "privateUsage";
+
+    /**
+     * token context
+     */
+    public static final String TOKEN = "authToken";
+    public static final String TOKEN_EXPIRATION = "tokenExpires";
+    public static final String TOKEN_CREATION = "tokenCreated";
+    public static final String USER_AGENT = "User-Agent";
+    public static final String HOST = "userIP";
+
+    public static final String QUERY_PARAM_URI = "uri";
+    public static final String QUERY_PARAM_USER = "user";
+
+    /**
+     * shibboleth attribute names
+     */
+    public static final String EPPN = "eppn";
+    public static final String COMMON_NAME = "cn";
+    public static final String SURNAME = "sn";
+
+    public static final String EDUPERSON = "eduPersonPrincipalName";
+    public static final String CN = "cn";
+    public static final String MAIL = "mail";
+    public static final String EDU_AFFIL = "eduPersonScopedAffiliation";
+
+    /**
+     * resource mappings
+     */
+
+    public static final String RID = "id";
+    public static final String OWNER = "owner";
+    public static final String NAME = "name";
+    public static final String DESCRIPTION = "description";
+
+    public static final String REF_CORPUS = "refCorpus";
+    public static final String QUERY = "query";
+    public static final String CACHE = "cache";
+    public static final String DOCIDS = "docIDs";
+    public static final String FOUNDRIES = "foundries";
+    public static final String DEFAULT_VALUE = "defaultColl";
+
+    public static final String FILE_FORMAT_FOR_EXPORT = "fileFormatForExport";
+    public static final String FILENAME_FOR_EXPORT = "fileNameForExport";
+    @Deprecated
+    public static final String ITEM_FOR_SIMPLE_ANNOTATION = "itemForSimpleAnnotation";
+    public static final String LEFT_CONTEXT_ITEM_FOR_EXPORT = "leftContextItemForExport";
+    public static final String LEFT_CONTEXT_SIZE_FOR_EXPORT = "leftContextSizeForExport";
+    public static final String LOCALE = "locale";
+    public static final String LEFT_CONTEXT_ITEM = "leftContextItem";
+    public static final String LEFT_CONTEXT_SIZE = "leftContextSize";
+    public static final String RIGHT_CONTEXT_ITEM = "rightContextItem";
+    public static final String RIGHT_CONTEXT_ITEM_FOR_EXPORT = "rightContextItemForExport";
+    public static final String RIGHT_CONTEXT_SIZE = "rightContextSize";
+    public static final String RIGHT_CONTEXT_SIZE_FOR_EXPORT = "rightContextSizeForExport";
+    public static final String SELECTED_COLLECTION = "selectedCollection";
+    public static final String QUERY_LANGUAGE = "queryLanguage";
+    public static final String PAGE_LENGTH = "pageLength";
+    public static final String METADATA_QUERY_EXPERT_MODUS = "metadataQueryExpertModus";
+    @Deprecated
+    public static final String SEARCH_SETTINGS_TAB = "searchSettingsTab";
+    @Deprecated
+    public static final String SELECTED_BROWSER_PROPERTY = "selectedBrowserProperty";
+    @Deprecated
+    public static final String SELECTED_CONTEXT_ITEM = "selectedContextItem";
+    @Deprecated
+    public static final String SELECTED_GRAPH_TYPE = "selectedGraphType";
+    @Deprecated
+    public static final String SELECTED_SORT_TYPE = "selectedSortType";
+    @Deprecated
+    public static final String SELECTED_VIEW_FOR_SEARCH_RESULTS = "selectedViewForSearchResults";
+    public static final String COLLECT_AUDITING_DATA = "collectData";
+
+    /**
+     * default layers
+     */
+    public static final String DEFAULT_POS_FOUNDRY = "POSFoundry";
+    public static final String DEFAULT_LEMMA_FOUNDRY = "lemmaFoundry";
+    public static final String DEFAULT_CONST_FOUNDRY = "constFoundry";
+    public static final String DEFAULT_REL_FOUNDRY = "relFoundry";
+
+    /**
+     * db column keys
+     */
+
+    public static final String SELF_REF = "self";
+
+    public static final String SYM_USE = "sym_use";
+    public static final String COMMERCIAL = "commercial";
+    public static final String LICENCE = "licence";
+    public static final String QUERY_ONLY = "query_only";
+    public static final String EXPORT = "export";
+    public static final String TIME_SPANS = "spans";
+    public static final String RANGE = "range";
+
+}
+
diff --git a/src/main/java/de/ids_mannheim/korap/user/DemoUser.java b/src/main/java/de/ids_mannheim/korap/user/DemoUser.java
new file mode 100644
index 0000000..c88f5e1
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/user/DemoUser.java
@@ -0,0 +1,29 @@
+package de.ids_mannheim.korap.user;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.Serializable;
+
+@Getter
+@Setter
+public class DemoUser extends User implements Serializable {
+    private static final long serialVersionUID = -5015206272520970500L;
+    public static final String DEMOUSER_NAME = "demo";
+    public static final Integer DEMOUSER_ID = 1654234534;
+    private static final long ACCOUNT_CREATED = 1377102171202L;
+    public static final String PASSPHRASE = "$2a$15$rGPvLWm5JJ1iYj0V61e5guYIGmSo.rjdBkAVIU1vWS/xdybmABxRa";
+
+    protected DemoUser() {
+        super(DEMOUSER_NAME, 2);
+        this.setDetails(new UserDetails());
+        this.setSettings(new UserSettings());
+        this.setAccountCreation(ACCOUNT_CREATED);
+        this.setQueries(UserQuery.demoUserQueries());
+    }
+
+    protected User clone() {
+        return new DemoUser();
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/user/KorAPUser.java b/src/main/java/de/ids_mannheim/korap/user/KorAPUser.java
new file mode 100644
index 0000000..5eb6932
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/user/KorAPUser.java
@@ -0,0 +1,76 @@
+package de.ids_mannheim.korap.user;
+
+import de.ids_mannheim.korap.utils.KorAPLogger;
+import lombok.Getter;
+import lombok.Setter;
+import org.slf4j.Logger;
+
+@Getter
+@Setter
+public class KorAPUser extends User {
+    private static Logger jlog = KorAPLogger.initiate(KorAPUser.class);
+    private static final long serialVersionUID = -7108308497625884584L;
+
+    //fixme: accountlink to shibboleth account
+    private String accountLink;
+
+    private String password;
+    private String URIFragment;
+    private Long URIExpiration;
+
+    protected KorAPUser(String username) {
+        super(username, 0);
+        this.URIFragment = "";
+        this.URIExpiration = 0L;
+    }
+
+    public KorAPUser(Integer id, String username) {
+        this(username);
+        this.setId(id);
+    }
+
+    public KorAPUser() {
+        super();
+    }
+
+    @Override
+    protected User clone() {
+        KorAPUser user = new KorAPUser(this.getUsername());
+        user.setUsername(this.getUsername());
+        user.setAccountCreation(this.getAccountCreation());
+        return user;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = super.hashCode();
+        result = 31 * result + (jlog != null ? jlog.hashCode() : 0);
+        result = 31 * result + (password != null ? password.hashCode() : 0);
+        result = 31 * result + (URIFragment != null ?
+                URIFragment.hashCode() :
+                0);
+        result = 31 * result + (URIExpiration != null ?
+                URIExpiration.hashCode() :
+                0);
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof KorAPUser))
+            return false;
+        if (!super.equals(o))
+            return false;
+
+        KorAPUser korAPUser = (KorAPUser) o;
+        if (URIExpiration != korAPUser.URIExpiration)
+            return false;
+        if (URIFragment != null ?
+                !URIFragment.equals(korAPUser.URIFragment) :
+                korAPUser.URIFragment != null)
+            return false;
+        return true;
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/user/ShibUser.java b/src/main/java/de/ids_mannheim/korap/user/ShibUser.java
new file mode 100644
index 0000000..f3f60b1
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/user/ShibUser.java
@@ -0,0 +1,48 @@
+package de.ids_mannheim.korap.user;
+
+import lombok.Data;
+
+/**
+ * User: hanl
+ * Date: 10/16/13
+ * Time: 2:02 PM
+ */
+@Data
+public class ShibUser extends User {
+
+    private String mail;
+    private String affiliation;
+    private String cn;
+
+    protected ShibUser() {
+        super(1);
+    }
+
+    private ShibUser(String eduPersonID, String mail, String cn, String affiliation) {
+        this(eduPersonID);
+        this.setUsername(eduPersonID);
+        this.mail = mail;
+        this.affiliation = affiliation;
+        this.cn = cn;
+    }
+
+    public ShibUser(String username) {
+        super(username, 1);
+
+    }
+
+    @Override
+    public String toString() {
+        final StringBuffer sb = new StringBuffer("ShibUser{");
+        sb.append(", mail='").append(mail).append('\'');
+        sb.append(", affiliation='").append(affiliation).append('\'');
+        sb.append(", cn='").append(cn).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    @Override
+    protected User clone() {
+        return new ShibUser(this.getUsername(), this.getMail(), this.getCn(), this.getAffiliation());
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/user/TokenContext.java b/src/main/java/de/ids_mannheim/korap/user/TokenContext.java
new file mode 100644
index 0000000..8f244d3
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/user/TokenContext.java
@@ -0,0 +1,116 @@
+package de.ids_mannheim.korap.user;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import de.ids_mannheim.korap.utils.JsonUtils;
+import lombok.Data;
+import org.joda.time.DateTime;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author hanl
+ * @date 27/01/2014
+ */
+@Data
+public class TokenContext implements java.security.Principal {
+
+    /**
+     * session relevant data. Are never persisted into a database
+     */
+    private String username;
+    private Date expirationTime;
+    // either "session_token " / "api_token
+    private String tokenType;
+    private String token;
+
+    private boolean secureRequired;
+
+    private Map<String, Object> parameters;
+    private String hostAddress;
+    private String userAgent;
+
+    public TokenContext(String username) {
+        this();
+        this.username = username;
+    }
+
+    private TokenContext() {
+        this.parameters = new HashMap<>();
+        this.setUsername("");
+        this.setToken("");
+        this.setSecureRequired(false);
+    }
+
+    private Map statusMap() {
+        Map m = new HashMap();
+        if (username != null && !username.isEmpty())
+            m.put(Attributes.USERNAME, username);
+        m.put(Attributes.TOKEN_EXPIRATION,
+                new DateTime(expirationTime).toString());
+        m.put(Attributes.TOKEN, this.token);
+        return m;
+    }
+
+    public boolean match(TokenContext other) {
+        if (other.getToken().equals(this.token))
+            if (this.getHostAddress().equals(this.hostAddress))
+                // user agent should be irrelvant -- what about os system version?
+                //                if (other.getUserAgent().equals(this.userAgent))
+                return true;
+        return false;
+    }
+
+    public void addContextParameter(String key, String value) {
+        this.parameters.put(key, value);
+    }
+
+    public void removeContextParameter(String key) {
+        this.parameters.remove(key);
+    }
+
+    public void setExpirationTime(long date) {
+        this.expirationTime = new Date(date);
+    }
+
+    public static TokenContext fromJSON(String s) {
+        JsonNode node = JsonUtils.readTree(s);
+        TokenContext c = new TokenContext(
+                node.path(Attributes.USERNAME).asText());
+        c.setToken(node.path(Attributes.TOKEN).asText());
+        return c;
+    }
+
+    public static TokenContext fromOAuth(String s) {
+        JsonNode node = JsonUtils.readTree(s);
+        TokenContext c = new TokenContext();
+        c.setToken(node.path("token").asText());
+        c.setTokenType(node.path("token_type").asText());
+        c.setExpirationTime(node.path("expires_in").asLong());
+        return c;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public String toJSON() {
+        return JsonUtils.toJSON(this.statusMap());
+    }
+
+    public String toResponse() {
+        ObjectNode node = JsonUtils.createObjectNode();
+        node.put("token", this.getToken());
+        node.put("expires", this.getExpirationTime().getTime());
+        node.put("token_type", this.getTokenType());
+        return JsonUtils.toJSON(node);
+    }
+
+    @Override
+    public String getName() {
+        return this.getUsername();
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/user/User.java b/src/main/java/de/ids_mannheim/korap/user/User.java
new file mode 100644
index 0000000..2b28edd
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/user/User.java
@@ -0,0 +1,214 @@
+package de.ids_mannheim.korap.user;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import de.ids_mannheim.korap.utils.JsonUtils;
+import de.ids_mannheim.korap.utils.TimeUtils;
+import lombok.Data;
+import org.joda.time.DateTime;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Data
+public abstract class User implements Serializable {
+
+    public static final int ADMINISTRATOR_ID = 34349733;
+    public static final String ADMINISTRATOR_NAME = "admin";
+
+    private Integer id;
+    // in local its username, in shib it's edupersonPrincipalName
+    private String username;
+    private Long accountCreation;
+    private boolean isAccountLocked;
+    private int type;
+    private Map<String, Object> fields;
+    private UserSettings settings;
+    private UserDetails details;
+    private List<UserQuery> queries;
+
+    protected User() {
+        this.accountCreation = TimeUtils.getNow().getMillis();
+        this.isAccountLocked = false;
+        this.username = "";
+        this.fields = new HashMap<>();
+        this.id = -1;
+    }
+
+    protected User(int type) {
+        this();
+        this.type = type;
+    }
+
+    protected User(String username, int type) {
+        this(type);
+        this.username = username;
+    }
+
+    public void setField(String key, Object value) {
+        this.fields.put(key, value);
+    }
+
+    public Object getField(String key) {
+        return this.fields.get(key);
+    }
+
+    //todo: repair transfer
+    public void transfer(User user) {
+        this.setSettings(user.getSettings());
+        this.setDetails(user.getDetails());
+        //        this.setQueries(user.getQueries());
+        if (this instanceof KorAPUser) {
+            this.getSettings().setUserID(this.id);
+            this.getDetails().setUserID(this.id);
+            //            for (UserQuery q : this.getQueries())
+            //                q.setOwner(this.accountID);
+        }
+    }
+
+    public void setDetails(UserDetails details) {
+        if (details != null)
+            details.setUserID(this.id);
+        this.details = details;
+    }
+
+    public void setSettings(UserSettings settings) {
+        if (settings != null)
+            settings.setUserID(this.id);
+        this.settings = settings;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+        if (this.settings != null)
+            this.settings.setUserID(this.id);
+        if (this.details != null)
+            this.details.setUserID(this.id);
+    }
+
+    public Map<String, Object> toMap() {
+        Map map = new HashMap();
+        map.put(Attributes.USERNAME, this.username);
+        //TimeUtils.format(new DateTime(this.accountCreation))
+        map.put(Attributes.ACCOUNT_CREATION, this.accountCreation);
+
+        if (this.getDetails() != null)
+            map.putAll(this.getDetails().toMap());
+        return map;
+    }
+
+    public String toJson() {
+        return JsonUtils.toJSON(this.toMap());
+    }
+
+    public Map toCache() {
+        Map map = new HashMap();
+        map.put(Attributes.UID, this.id);
+        map.put(Attributes.USERNAME, this.username);
+        map.put(Attributes.ACCOUNT_CREATION,
+                TimeUtils.format(new DateTime(this.accountCreation)));
+        map.put(Attributes.ACCOUNTLOCK, this.isAccountLocked);
+        map.put(Attributes.TYPE, this.type);
+        return map;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof User))
+            return false;
+        User user = (User) o;
+        if (!username.equals(user.username))
+            return false;
+        return true;
+    }
+
+    public boolean isDemo() {
+        return this.getUsername().equalsIgnoreCase(DemoUser.DEMOUSER_NAME);
+    }
+
+    public boolean isAdmin() {
+        return this.getUsername().equals(ADMINISTRATOR_ID);
+    }
+
+    protected abstract User clone();
+
+    @Override
+    public String toString() {
+        final StringBuffer sb = new StringBuffer();
+        sb.append("id='").append(id).append('\'');
+        sb.append(", username='").append(username).append('\'');
+        return sb.toString();
+    }
+
+    public static class UserFactory {
+
+        public static KorAPUser getUser(String username) {
+            return new KorAPUser(username);
+        }
+
+        public static KorAPUser getAdmin() {
+            return new KorAPUser(ADMINISTRATOR_ID, ADMINISTRATOR_NAME);
+        }
+
+        public static DemoUser getDemoUser() {
+            return new DemoUser();
+        }
+
+        public static DemoUser getDemoUser(Integer id) {
+            DemoUser demo = new DemoUser();
+            demo.setId(id);
+            return demo;
+        }
+
+        public static ShibUser getShibInstance(String eduPersonID, String mail,
+                String cn) {
+            ShibUser u = new ShibUser(eduPersonID);
+            u.setAffiliation("");
+            u.setMail(mail);
+            u.setUsername(eduPersonID);
+            u.setCn(cn);
+            return u;
+        }
+
+        public static User toUser(Map map) {
+            int type = map.get(Attributes.TYPE) == null ?
+                    0 :
+                    (int) map.get(Attributes.TYPE);
+            User user;
+            DateTime dateTime = DateTime
+                    .parse((String) map.get(Attributes.ACCOUNT_CREATION));
+            switch (type) {
+                case 0:
+                    user = UserFactory
+                            .getUser((String) map.get(Attributes.USERNAME));
+                    user.setId((Integer) map.get(Attributes.UID));
+                    user.setAccountLocked(
+                            (Boolean) map.get(Attributes.ACCOUNTLOCK));
+                    user.setAccountCreation(dateTime.getMillis());
+                    break;
+                default:
+                    user = UserFactory
+                            .getDemoUser((Integer) map.get(Attributes.UID));
+                    user.setAccountCreation(dateTime.getMillis());
+            }
+            return user;
+        }
+
+        public static KorAPUser toUser(String value) {
+            JsonNode node = JsonUtils.readTree(value);
+            KorAPUser user = UserFactory
+                    .getUser(node.path(Attributes.USERNAME).asText());
+            user.setAccountLocked(
+                    node.path(Attributes.ACCOUNTLOCK).asBoolean());
+            user.setAccountLink(node.path(Attributes.ACCOUNTLINK).asText());
+            user.setAccountCreation(
+                    node.path(Attributes.ACCOUNT_CREATION).asLong());
+            user.setPassword(node.path(Attributes.PASSWORD).asText());
+            return user;
+        }
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/user/UserDetails.java b/src/main/java/de/ids_mannheim/korap/user/UserDetails.java
new file mode 100644
index 0000000..6b2ffdb
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/user/UserDetails.java
@@ -0,0 +1,111 @@
+package de.ids_mannheim.korap.user;
+
+import lombok.Data;
+import org.apache.commons.collections.map.CaseInsensitiveMap;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * User: hanl
+ * Date: 8/14/13
+ * Time: 10:32 AM
+ */
+
+@Data
+public class UserDetails {
+
+    private Integer Id;
+    private Integer userID;
+    private String firstName;
+    private String lastName;
+    private String gender;
+    private String phone;
+    private String institution;
+    private String email;
+    private String address;
+    private String country;
+    private boolean privateUsage;
+
+    public UserDetails() {
+        setFirstName("");
+        setLastName("");
+        setPhone("");
+        setEmail("");
+        setGender("");
+        setAddress("");
+        setCountry("");
+        setInstitution("");
+        setPrivateUsage(true);
+    }
+
+    public static UserDetails newDetailsIterator(Map<String, Object> d) {
+        UserDetails details = new UserDetails();
+        Map<String, Object> detailMap = new CaseInsensitiveMap(d);
+
+        if (!detailMap.isEmpty()) {
+            details.setFirstName((String) detailMap.get(Attributes.FIRSTNAME));
+            details.setLastName((String) detailMap.get(Attributes.LASTNAME));
+            details.setPhone((String) detailMap.get(Attributes.PHONE));
+            details.setEmail((String) detailMap.get(Attributes.EMAIL));
+            details.setGender((String) detailMap.get(Attributes.GENDER));
+            details.setAddress((String) detailMap.get(Attributes.ADDRESS));
+            details.setCountry((String) detailMap.get(Attributes.COUNTRY));
+            details.setInstitution(
+                    (String) detailMap.get(Attributes.INSTITUTION));
+            details.setPrivateUsage(
+                    detailMap.get(Attributes.PRIVATE_USAGE) == null ?
+                            true :
+                            (Boolean) detailMap.get(Attributes.PRIVATE_USAGE));
+        }
+        return details;
+    }
+
+    public void updateDetails(Map<String, String> d) {
+        Map<String, String> detailMap = new CaseInsensitiveMap(d);
+
+        if (!detailMap.isEmpty()) {
+            if (detailMap.containsKey(Attributes.FIRSTNAME))
+                this.setFirstName(detailMap.get(Attributes.FIRSTNAME));
+            if (detailMap.containsKey(Attributes.LASTNAME))
+                this.setLastName(detailMap.get(Attributes.LASTNAME));
+            if (detailMap.containsKey(Attributes.PHONE))
+                this.setPhone(detailMap.get(Attributes.PHONE));
+            if (detailMap.containsKey(Attributes.EMAIL))
+                this.setEmail(detailMap.get(Attributes.EMAIL));
+            if (detailMap.containsKey(Attributes.GENDER))
+                this.setGender(detailMap.get(Attributes.GENDER));
+            if (detailMap.containsKey(Attributes.ADDRESS))
+                this.setAddress(detailMap.get(Attributes.ADDRESS));
+            if (detailMap.containsKey(Attributes.COUNTRY))
+                this.setCountry(detailMap.get(Attributes.COUNTRY));
+            if (detailMap.containsKey(Attributes.INSTITUTION))
+                this.setInstitution(detailMap.get(Attributes.INSTITUTION));
+            this.setPrivateUsage(
+                    Boolean.valueOf(detailMap.get(Attributes.PRIVATE_USAGE)));
+        }
+    }
+
+    public Map<String, Object> toMap() {
+        Map<String, Object> details = new HashMap<>();
+        // shouldnt there be a mechanism that prevents the retrieval of all information if no scopes are given?
+        // and if so, are the access_tokens specific to the scopes then?
+        details.put(Attributes.EMAIL, this.email);
+        details.put(Attributes.FIRSTNAME, this.firstName);
+        details.put(Attributes.LASTNAME, this.lastName);
+        details.put(Attributes.GENDER, this.gender);
+        details.put(Attributes.PHONE, this.phone);
+        details.put(Attributes.INSTITUTION, this.institution);
+        details.put(Attributes.ADDRESS, this.address);
+        details.put(Attributes.COUNTRY, this.country);
+        details.put(Attributes.PRIVATE_USAGE, this.privateUsage);
+
+        for (Map.Entry<String, Object> pair : details.entrySet()) {
+            if (pair.getValue() == null || pair.getValue().equals("null"))
+                pair.setValue("");
+        }
+        return details;
+    }
+
+}
+
diff --git a/src/main/java/de/ids_mannheim/korap/user/UserQuery.java b/src/main/java/de/ids_mannheim/korap/user/UserQuery.java
new file mode 100644
index 0000000..0e53aa0
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/user/UserQuery.java
@@ -0,0 +1,136 @@
+package de.ids_mannheim.korap.user;
+
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * User: hanl
+ * Date: 9/16/13
+ * Time: 4:38 PM
+ */
+@Data
+public class UserQuery {
+
+    private Integer id;
+    private String queryLanguage;
+    private String query;
+    private String name;
+    private String description;
+    private Integer creator;
+
+    public UserQuery(Integer id, int creator) {
+        setId(id);
+        setCreator(creator);
+        setName("");
+        setDescription("");
+        setQuery("");
+        setQueryLanguage("");
+    }
+
+    public UserQuery(String ql, String query, String description) {
+        setDescription(description);
+        setQuery(query);
+        setQueryLanguage(ql);
+    }
+
+    public UserQuery() {
+        setDescription("");
+        setQuery("");
+        setQueryLanguage("");
+        setName("");
+    }
+
+    public void setQuery(String query) {
+        this.query = query;
+        setName("Query: " + query
+                .substring(0, query.length() > 20 ? 20 : query.length()));
+    }
+
+    // todo: use example queries or store in database
+    public static List<UserQuery> demoUserQueries() {
+
+        List<UserQuery> queries = new ArrayList<>();
+        UserQuery q1 = new UserQuery();
+        q1.setQueryLanguage("COSMAS2");
+        q1.setQuery("$wegen #IN(L) <s>");
+        q1.setDescription(
+                "Findet 'wegen' an Satzanfängen. Berücksichtigt auch Groß- und Kleinschreibung");
+
+        //todo: change query
+        UserQuery q2 = new UserQuery();
+        q2.setQueryLanguage("COSMAS2");
+        q2.setQuery("base/cons:Buchstabe base/aggr:Buchstabe");
+
+        UserQuery q3 = new UserQuery();
+        q3.setQueryLanguage("COSMAS2");
+        q3.setDescription("Regular Expression Search");
+        q3.setQuery("id:/WPD_AAA.*/ AND textClass:sport");
+
+        UserQuery q4 = new UserQuery();
+        q4.setQueryLanguage("COSMAS2");
+        q4.setQuery("mpt/syntax_pos:@CC\\|und");
+
+        UserQuery q5 = new UserQuery();
+        q5.setQueryLanguage("COSMAS2");
+        q5.setQuery("VVINF\\|.*en");
+
+        queries.add(q1);
+        //        queries.add(q2);
+        //        queries.add(q3);
+        queries.add(q4);
+        queries.add(q5);
+        return queries;
+    }
+
+    //id is irrevelant, since data was coming
+    // from frontend and thus this object does not contain a id that could be compared!
+    // same with the userAccount. Not set yet!
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof UserQuery))
+            return false;
+        UserQuery userQuery = (UserQuery) o;
+        if (!query.equals(userQuery.query))
+            return false;
+        if (!queryLanguage.equals(userQuery.queryLanguage))
+            return false;
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = getId() != null ? getId().hashCode() : 0;
+        result = 31 * result + (queryLanguage != null ?
+                queryLanguage.hashCode() :
+                0);
+        result = 31 * result + (query != null ? query.hashCode() : 0);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuffer sb = new StringBuffer("UserQuery{");
+        sb.append("id=").append(getId());
+        //        sb.append(", owner=").append(getOwner());
+        sb.append(", queryLanguage='").append(queryLanguage).append('\'');
+        sb.append(", query='").append(query).append('\'');
+        sb.append(", description='").append(getDescription()).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public Map toMap() {
+        Map map = new HashMap();
+        map.put("name", this.name);
+        map.put("description", this.description);
+        map.put("query", this.query);
+        map.put("queryLanguage", this.queryLanguage);
+        return map;
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/user/UserSettings.java b/src/main/java/de/ids_mannheim/korap/user/UserSettings.java
new file mode 100644
index 0000000..365e69a
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/user/UserSettings.java
@@ -0,0 +1,467 @@
+package de.ids_mannheim.korap.user;
+
+import de.ids_mannheim.korap.utils.BooleanUtils;
+import de.ids_mannheim.korap.utils.JsonUtils;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * User: hanl
+ * Date: 8/14/13
+ * Time: 10:26 AM
+ */
+
+@Getter
+@Setter
+public class UserSettings {
+
+    private Integer id;
+    private Integer userID;
+    private String fileNameForExport;
+    //    @Deprecated
+    //    private Integer itemForSimpleAnnotation;
+    private String leftContextItemForExport;
+    private Integer leftContextSizeForExport;
+    private String locale;
+    private String leftContextItem;
+    private Integer leftContextSize;
+    private String rightContextItem;
+    private String rightContextItemForExport;
+    private Integer rightContextSize;
+    private Integer rightContextSizeForExport;
+    private String selectedCollection;
+    private String queryLanguage;
+    private Integer pageLength;
+    private boolean metadataQueryExpertModus;
+    //    @Deprecated
+    //    private Integer searchSettingsTab;
+    //    @Deprecated
+    //    private Integer selectedGraphType;
+    //    @Deprecated
+    //    private String selectedSortType;
+    //    @Deprecated
+    //    private String selectedViewForSearchResults;
+
+    /**
+     * default values for foundry specification! of structure ff/lay
+     */
+    private String defaultPOSfoundry;
+    private String defaultLemmafoundry;
+    //default foundry for constituent information (syntax trees) --> there is no actual layer for this information
+    private String defaultConstfoundry;
+    private String defaultRelfoundry;
+
+    //todo: refactor to anonymous -- since data is collected either way!
+    private boolean collectData;
+
+    /**
+     * creates an instance of this object with default values, mapped from a database/configuration file
+     */
+    public UserSettings() {
+        setupDefaultSettings();
+    }
+
+    public static UserSettings fromObjectMap(Map<String, Object> m) {
+        UserSettings s = new UserSettings();
+        s.setFileNameForExport((String) m.get(Attributes.FILENAME_FOR_EXPORT));
+        //        s.setItemForSimpleAnnotation(
+        //                (Integer) m.get(Attributes.ITEM_FOR_SIMPLE_ANNOTATION));
+        s.setLeftContextItemForExport(
+                (String) m.get(Attributes.LEFT_CONTEXT_ITEM_FOR_EXPORT));
+        s.setLeftContextSizeForExport(
+                (Integer) m.get(Attributes.LEFT_CONTEXT_SIZE_FOR_EXPORT));
+        s.setLocale((String) m.get(Attributes.LOCALE));
+        s.setLeftContextItem((String) m.get(Attributes.LEFT_CONTEXT_ITEM));
+        s.setLeftContextSize((Integer) m.get(Attributes.LEFT_CONTEXT_SIZE));
+        s.setRightContextItem((String) m.get(Attributes.RIGHT_CONTEXT_ITEM));
+        s.setRightContextItemForExport(
+                (String) m.get(Attributes.RIGHT_CONTEXT_ITEM_FOR_EXPORT));
+        s.setRightContextSize((Integer) m.get(Attributes.RIGHT_CONTEXT_SIZE));
+        s.setRightContextSizeForExport(
+                (Integer) m.get(Attributes.RIGHT_CONTEXT_SIZE_FOR_EXPORT));
+        s.setSelectedCollection((String) m.get(Attributes.SELECTED_COLLECTION));
+        s.setQueryLanguage((String) m.get(Attributes.QUERY_LANGUAGE));
+        s.setPageLength((Integer) m.get(Attributes.PAGE_LENGTH));
+        s.setMetadataQueryExpertModus((Boolean) BooleanUtils
+                .getBoolean(m.get(Attributes.METADATA_QUERY_EXPERT_MODUS)));
+        //        s.setSearchSettingsTab((Integer) m.get(Attributes.SEARCH_SETTINGS_TAB));
+        //        s.setSelectedGraphType((Integer) m.get(Attributes.SELECTED_GRAPH_TYPE));
+        //        s.setSelectedSortType((String) m.get(Attributes.SELECTED_SORT_TYPE));
+        //        s.setSelectedViewForSearchResults(
+        //                (String) m.get(Attributes.SELECTED_VIEW_FOR_SEARCH_RESULTS));
+        s.setCollectData((Boolean) BooleanUtils
+                .getBoolean(m.get(Attributes.COLLECT_AUDITING_DATA)));
+
+        s.setDefaultConstfoundry(
+                (String) m.get(Attributes.DEFAULT_CONST_FOUNDRY));
+        s.setDefaultRelfoundry((String) m.get(Attributes.DEFAULT_REL_FOUNDRY));
+        s.setDefaultPOSfoundry((String) m.get(Attributes.DEFAULT_POS_FOUNDRY));
+        s.setDefaultLemmafoundry(
+                (String) m.get(Attributes.DEFAULT_LEMMA_FOUNDRY));
+
+        s.setId((Integer) m.get("Id"));
+        s.setUserID((Integer) m.get("userID"));
+        return s;
+    }
+
+    public static UserSettings fromMap(Map<String, String> m) {
+        UserSettings s = new UserSettings();
+        s.setFileNameForExport(m.get(Attributes.FILENAME_FOR_EXPORT));
+        //        s.setItemForSimpleAnnotation(
+        //                Integer.valueOf(m.get(Attributes.ITEM_FOR_SIMPLE_ANNOTATION)));
+        s.setLeftContextItemForExport(
+                m.get(Attributes.LEFT_CONTEXT_ITEM_FOR_EXPORT));
+        s.setLeftContextSizeForExport(Integer.valueOf(
+                m.get(Attributes.LEFT_CONTEXT_SIZE_FOR_EXPORT)));
+        s.setLocale(m.get(Attributes.LOCALE));
+        s.setLeftContextItem(m.get(Attributes.LEFT_CONTEXT_ITEM));
+        s.setLeftContextSize(
+                Integer.valueOf(m.get(Attributes.LEFT_CONTEXT_SIZE)));
+        s.setRightContextItem(m.get(Attributes.RIGHT_CONTEXT_ITEM));
+        s.setRightContextItemForExport(
+                m.get(Attributes.RIGHT_CONTEXT_ITEM_FOR_EXPORT));
+        s.setRightContextSize(
+                Integer.valueOf(m.get(Attributes.RIGHT_CONTEXT_SIZE)));
+        s.setRightContextSizeForExport(Integer.valueOf(
+                m.get(Attributes.RIGHT_CONTEXT_SIZE_FOR_EXPORT)));
+        s.setSelectedCollection(m.get(Attributes.SELECTED_COLLECTION));
+        s.setQueryLanguage(m.get(Attributes.QUERY_LANGUAGE));
+        s.setPageLength(Integer.valueOf(m.get(Attributes.PAGE_LENGTH)));
+        s.setMetadataQueryExpertModus(
+                Boolean.valueOf(m.get(Attributes.METADATA_QUERY_EXPERT_MODUS)));
+        //        s.setSearchSettingsTab(
+        //                Integer.valueOf(m.get(Attributes.SEARCH_SETTINGS_TAB)));
+        //        s.setSelectedGraphType(
+        //                Integer.valueOf(m.get(Attributes.SELECTED_GRAPH_TYPE)));
+        //        s.setSelectedSortType(m.get(Attributes.SELECTED_SORT_TYPE));
+        //        s.setSelectedViewForSearchResults(
+        //                m.get(Attributes.SELECTED_VIEW_FOR_SEARCH_RESULTS));
+
+        s.setCollectData(
+                Boolean.valueOf(m.get(Attributes.COLLECT_AUDITING_DATA)));
+        s.setDefaultConstfoundry(m.get(Attributes.DEFAULT_CONST_FOUNDRY));
+        s.setDefaultRelfoundry(m.get(Attributes.DEFAULT_REL_FOUNDRY));
+        s.setDefaultPOSfoundry(m.get(Attributes.DEFAULT_POS_FOUNDRY));
+        s.setDefaultLemmafoundry(m.get(Attributes.DEFAULT_LEMMA_FOUNDRY));
+        return s;
+    }
+
+    public static UserSettings newSettingsIterator(Map<String, String> m) {
+        UserSettings s = new UserSettings();
+        if (m.isEmpty())
+            return s;
+
+        s.setFileNameForExport(m.get(Attributes.FILENAME_FOR_EXPORT));
+        //        s.setItemForSimpleAnnotation(
+        //                Integer.valueOf(m.get(Attributes.ITEM_FOR_SIMPLE_ANNOTATION)));
+        s.setLeftContextItemForExport(
+                m.get(Attributes.LEFT_CONTEXT_ITEM_FOR_EXPORT));
+        s.setLeftContextSizeForExport(Integer.valueOf(
+                m.get(Attributes.LEFT_CONTEXT_SIZE_FOR_EXPORT)));
+        s.setLocale(m.get(Attributes.LOCALE));
+        s.setLeftContextItem(m.get(Attributes.LEFT_CONTEXT_ITEM));
+        s.setLeftContextSize(
+                Integer.valueOf(m.get(Attributes.LEFT_CONTEXT_SIZE)));
+        s.setRightContextItem(m.get(Attributes.RIGHT_CONTEXT_ITEM));
+        s.setRightContextItemForExport(
+                m.get(Attributes.RIGHT_CONTEXT_ITEM_FOR_EXPORT));
+        s.setRightContextSize(
+                Integer.valueOf(m.get(Attributes.RIGHT_CONTEXT_SIZE)));
+        s.setRightContextSizeForExport(Integer.valueOf(
+                m.get(Attributes.RIGHT_CONTEXT_SIZE_FOR_EXPORT)));
+        s.setSelectedCollection(m.get(Attributes.SELECTED_COLLECTION));
+        s.setQueryLanguage(m.get(Attributes.QUERY_LANGUAGE));
+        s.setPageLength(Integer.valueOf(m.get(Attributes.PAGE_LENGTH)));
+        s.setMetadataQueryExpertModus(
+                Boolean.valueOf(m.get(Attributes.METADATA_QUERY_EXPERT_MODUS)));
+        //        s.setSearchSettingsTab(
+        //                Integer.valueOf(m.get(Attributes.SEARCH_SETTINGS_TAB)));
+        //        s.setSelectedGraphType(
+        //                Integer.valueOf(m.get(Attributes.SELECTED_GRAPH_TYPE)));
+        //        s.setSelectedSortType(m.get(Attributes.SELECTED_SORT_TYPE));
+        //        s.setSelectedViewForSearchResults(
+        //                m.get(Attributes.SELECTED_VIEW_FOR_SEARCH_RESULTS));
+
+        s.setCollectData(
+                Boolean.valueOf(m.get(Attributes.COLLECT_AUDITING_DATA)));
+        s.setDefaultConstfoundry(m.get(Attributes.DEFAULT_CONST_FOUNDRY));
+        s.setDefaultRelfoundry(m.get(Attributes.DEFAULT_REL_FOUNDRY));
+        s.setDefaultPOSfoundry(m.get(Attributes.DEFAULT_POS_FOUNDRY));
+        s.setDefaultLemmafoundry(m.get(Attributes.DEFAULT_LEMMA_FOUNDRY));
+        return s;
+    }
+
+    public void updateStringSettings(Map<String, String> m) {
+        this.setFileNameForExport(m.get(Attributes.FILENAME_FOR_EXPORT));
+        //        this.setItemForSimpleAnnotation(
+        //                Integer.valueOf(m.get(Attributes.ITEM_FOR_SIMPLE_ANNOTATION)));
+        this.setLeftContextItemForExport(
+                m.get(Attributes.LEFT_CONTEXT_ITEM_FOR_EXPORT));
+        this.setLeftContextSizeForExport(Integer.valueOf(
+                m.get(Attributes.LEFT_CONTEXT_SIZE_FOR_EXPORT)));
+        this.setLocale(m.get(Attributes.LOCALE));
+        this.setLeftContextItem(m.get(Attributes.LEFT_CONTEXT_ITEM));
+        this.setLeftContextSize(
+                Integer.valueOf(m.get(Attributes.LEFT_CONTEXT_SIZE)));
+        this.setRightContextItem(m.get(Attributes.RIGHT_CONTEXT_ITEM));
+        this.setRightContextItemForExport(
+                m.get(Attributes.RIGHT_CONTEXT_ITEM_FOR_EXPORT));
+        this.setRightContextSize(
+                Integer.valueOf(m.get(Attributes.RIGHT_CONTEXT_SIZE)));
+        this.setRightContextSizeForExport(Integer.valueOf(
+                m.get(Attributes.RIGHT_CONTEXT_SIZE_FOR_EXPORT)));
+        this.setSelectedCollection(m.get(Attributes.SELECTED_COLLECTION));
+        this.setQueryLanguage(m.get(Attributes.QUERY_LANGUAGE));
+        this.setPageLength(Integer.valueOf(m.get(Attributes.PAGE_LENGTH)));
+        this.setMetadataQueryExpertModus(
+                Boolean.valueOf(m.get(Attributes.METADATA_QUERY_EXPERT_MODUS)));
+        //        this.setSearchSettingsTab(
+        //                Integer.valueOf(m.get(Attributes.SEARCH_SETTINGS_TAB)));
+        //        this.setSelectedGraphType(
+        //                Integer.valueOf(m.get(Attributes.SELECTED_GRAPH_TYPE)));
+        //        this.setSelectedSortType(m.get(Attributes.SELECTED_SORT_TYPE));
+        //        this.setSelectedViewForSearchResults(
+        //                m.get(Attributes.SELECTED_VIEW_FOR_SEARCH_RESULTS));
+
+        this.setCollectData(
+                Boolean.valueOf(m.get(Attributes.COLLECT_AUDITING_DATA)));
+        this.setDefaultPOSfoundry(m.get(Attributes.DEFAULT_POS_FOUNDRY));
+        this.setDefaultLemmafoundry(m.get(Attributes.DEFAULT_LEMMA_FOUNDRY));
+        this.setDefaultConstfoundry(m.get(Attributes.DEFAULT_CONST_FOUNDRY));
+        this.setDefaultRelfoundry(m.get(Attributes.DEFAULT_REL_FOUNDRY));
+    }
+
+    public void updateObjectSettings(Map<String, Object> m) {
+        this.setFileNameForExport(
+                (String) m.get(Attributes.FILENAME_FOR_EXPORT));
+        //        this.setItemForSimpleAnnotation(
+        //                (Integer) m.get(Attributes.ITEM_FOR_SIMPLE_ANNOTATION));
+        this.setLeftContextItemForExport(
+                (String) m.get(Attributes.LEFT_CONTEXT_ITEM_FOR_EXPORT));
+        this.setLeftContextSizeForExport(
+                (Integer) m.get(Attributes.LEFT_CONTEXT_SIZE_FOR_EXPORT));
+        this.setLocale((String) m.get(Attributes.LOCALE));
+        this.setLeftContextItem((String) m.get(Attributes.LEFT_CONTEXT_ITEM));
+        this.setLeftContextSize((Integer) m.get(Attributes.LEFT_CONTEXT_SIZE));
+        this.setRightContextItem((String) m.get(Attributes.RIGHT_CONTEXT_ITEM));
+        this.setRightContextItemForExport(
+                (String) m.get(Attributes.RIGHT_CONTEXT_ITEM_FOR_EXPORT));
+        this.setRightContextSize(
+                (Integer) m.get(Attributes.RIGHT_CONTEXT_SIZE));
+        this.setRightContextSizeForExport(
+                (Integer) m.get(Attributes.RIGHT_CONTEXT_SIZE_FOR_EXPORT));
+        this.setSelectedCollection(
+                (String) m.get(Attributes.SELECTED_COLLECTION));
+        this.setQueryLanguage((String) m.get(Attributes.QUERY_LANGUAGE));
+        this.setPageLength((Integer) m.get(Attributes.PAGE_LENGTH));
+        this.setMetadataQueryExpertModus(
+                (Boolean) m.get(Attributes.METADATA_QUERY_EXPERT_MODUS));
+        //        this.setSearchSettingsTab(
+        //                (Integer) m.get(Attributes.SEARCH_SETTINGS_TAB));
+        //        this.setSelectedGraphType(
+        //                (Integer) m.get(Attributes.SELECTED_GRAPH_TYPE));
+        //        this.setSelectedSortType((String) m.get(Attributes.SELECTED_SORT_TYPE));
+        //        this.setSelectedViewForSearchResults(
+        //                (String) m.get(Attributes.SELECTED_VIEW_FOR_SEARCH_RESULTS));
+
+        this.setCollectData((Boolean) m.get(Attributes.COLLECT_AUDITING_DATA));
+        this.setDefaultPOSfoundry(
+                (String) m.get(Attributes.DEFAULT_POS_FOUNDRY));
+        this.setDefaultLemmafoundry(
+                (String) m.get(Attributes.DEFAULT_LEMMA_FOUNDRY));
+        this.setDefaultConstfoundry(
+                (String) m.get(Attributes.DEFAULT_CONST_FOUNDRY));
+        this.setDefaultRelfoundry(
+                (String) m.get(Attributes.DEFAULT_REL_FOUNDRY));
+    }
+
+    //load from configuration?
+    private void setupDefaultSettings() {
+        this.setFileNameForExport("export");
+        //        this.setItemForSimpleAnnotation(0);
+        this.setLocale("de");
+        this.setLeftContextItemForExport("char");
+        this.setLeftContextSizeForExport(100);
+        this.setLeftContextItem("char");
+        this.setLeftContextSize(200);
+        this.setRightContextItem("char");
+        this.setRightContextItemForExport("char");
+        this.setRightContextSize(200);
+        this.setRightContextSizeForExport(100);
+        // persistent id for wikipedia!
+        this.setSelectedCollection(
+                "ZGU0ZTllNTFkYzc3M2VhZmViYzdkYWE2ODI5NDc3NTk4NGQ1YThhOTMwOTNhOWYxNWMwN2M3Y2YyZmE3N2RlNQ==");
+        this.setQueryLanguage("COSMAS2");
+        this.setPageLength(25);
+        this.setMetadataQueryExpertModus(true);
+        //        this.setSearchSettingsTab(0);
+        //        this.setSelectedGraphType(1);
+        //        this.setSelectedSortType("FIFO");
+        //        this.setSelectedViewForSearchResults("KWIC");
+
+        this.setCollectData(true);
+        this.setDefaultConstfoundry("mate");
+        this.setDefaultRelfoundry("mate");
+        this.setDefaultPOSfoundry("tt");
+        this.setDefaultLemmafoundry("tt");
+    }
+
+    public Map toStringMap() {
+        Map<String, String> m = new HashMap<>();
+        m.put(Attributes.FILENAME_FOR_EXPORT, this.getFileNameForExport());
+        //        m.put(Attributes.ITEM_FOR_SIMPLE_ANNOTATION,
+        //                String.valueOf(this.getItemForSimpleAnnotation()));
+        m.put(Attributes.LEFT_CONTEXT_SIZE,
+                String.valueOf(this.getLeftContextSize()));
+        m.put(Attributes.LEFT_CONTEXT_ITEM,
+                String.valueOf(this.getLeftContextItem()));
+        m.put(Attributes.LOCALE, this.getLocale());
+        m.put(Attributes.LEFT_CONTEXT_SIZE_FOR_EXPORT,
+                String.valueOf(this.getLeftContextSizeForExport()));
+        m.put(Attributes.LEFT_CONTEXT_ITEM_FOR_EXPORT,
+                String.valueOf(this.getLeftContextItemForExport()));
+        m.put(Attributes.RIGHT_CONTEXT_ITEM,
+                String.valueOf(this.getRightContextItem()));
+        m.put(Attributes.RIGHT_CONTEXT_SIZE,
+                String.valueOf(this.getRightContextSize()));
+        m.put(Attributes.RIGHT_CONTEXT_ITEM_FOR_EXPORT,
+                String.valueOf(this.getRightContextItemForExport()));
+        m.put(Attributes.RIGHT_CONTEXT_SIZE_FOR_EXPORT,
+                String.valueOf(this.getRightContextSizeForExport()));
+        m.put(Attributes.SELECTED_COLLECTION, this.getSelectedCollection());
+        m.put(Attributes.QUERY_LANGUAGE, this.getQueryLanguage());
+        m.put(Attributes.PAGE_LENGTH, String.valueOf(this.getPageLength()));
+        m.put(Attributes.METADATA_QUERY_EXPERT_MODUS,
+                String.valueOf(this.isMetadataQueryExpertModus()));
+        //        m.put(Attributes.SEARCH_SETTINGS_TAB,
+        //                String.valueOf(this.getSearchSettingsTab()));
+        //        m.put(Attributes.SELECTED_GRAPH_TYPE,
+        //                String.valueOf(this.getSelectedGraphType()));
+        //        m.put(Attributes.SELECTED_SORT_TYPE, this.getSelectedSortType());
+        //        m.put(Attributes.SELECTED_VIEW_FOR_SEARCH_RESULTS,
+        //                this.getSelectedViewForSearchResults());
+        m.put(Attributes.DEFAULT_POS_FOUNDRY, this.getDefaultPOSfoundry());
+        m.put(Attributes.DEFAULT_LEMMA_FOUNDRY, this.getDefaultLemmafoundry());
+        m.put(Attributes.DEFAULT_CONST_FOUNDRY, this.getDefaultConstfoundry());
+        m.put(Attributes.DEFAULT_REL_FOUNDRY, this.getDefaultRelfoundry());
+        m.put(Attributes.COLLECT_AUDITING_DATA,
+                String.valueOf(this.isCollectData()));
+
+        for (Map.Entry pair : m.entrySet()) {
+            if (pair.getValue() == null)
+                pair.setValue("");
+        }
+        return m;
+    }
+
+    public Map toObjectMap() {
+        Map<String, Object> m = new HashMap<>();
+        m.put(Attributes.FILENAME_FOR_EXPORT, this.getFileNameForExport());
+        //        m.put(Attributes.ITEM_FOR_SIMPLE_ANNOTATION,
+        //                this.getItemForSimpleAnnotation());
+        m.put(Attributes.LEFT_CONTEXT_SIZE, this.getLeftContextSize());
+        m.put(Attributes.LEFT_CONTEXT_ITEM, this.getLeftContextItem());
+        m.put(Attributes.LOCALE, this.getLocale());
+        m.put(Attributes.LEFT_CONTEXT_SIZE_FOR_EXPORT,
+                this.getLeftContextSizeForExport());
+        m.put(Attributes.LEFT_CONTEXT_ITEM_FOR_EXPORT,
+                this.getLeftContextItemForExport());
+        m.put(Attributes.RIGHT_CONTEXT_ITEM, this.getRightContextItem());
+        m.put(Attributes.RIGHT_CONTEXT_SIZE, this.getRightContextSize());
+        m.put(Attributes.RIGHT_CONTEXT_ITEM_FOR_EXPORT,
+                this.getRightContextItemForExport());
+        m.put(Attributes.RIGHT_CONTEXT_SIZE_FOR_EXPORT,
+                this.getRightContextSizeForExport());
+        m.put(Attributes.SELECTED_COLLECTION, this.getSelectedCollection());
+        m.put(Attributes.QUERY_LANGUAGE, this.getQueryLanguage());
+        m.put(Attributes.PAGE_LENGTH, this.getPageLength());
+        m.put(Attributes.METADATA_QUERY_EXPERT_MODUS,
+                this.isMetadataQueryExpertModus());
+        //        m.put(Attributes.SEARCH_SETTINGS_TAB, this.getSearchSettingsTab());
+        //        m.put(Attributes.SELECTED_GRAPH_TYPE, this.getSelectedGraphType());
+        //        m.put(Attributes.SELECTED_SORT_TYPE, this.getSelectedSortType());
+        //        m.put(Attributes.SELECTED_VIEW_FOR_SEARCH_RESULTS,
+        //                this.getSelectedViewForSearchResults());
+        m.put(Attributes.DEFAULT_POS_FOUNDRY, this.getDefaultPOSfoundry());
+        m.put(Attributes.DEFAULT_LEMMA_FOUNDRY, this.getDefaultLemmafoundry());
+        m.put(Attributes.DEFAULT_CONST_FOUNDRY, this.getDefaultConstfoundry());
+        m.put(Attributes.DEFAULT_REL_FOUNDRY, this.getDefaultRelfoundry());
+        m.put(Attributes.COLLECT_AUDITING_DATA, this.isCollectData());
+        for (Map.Entry pair : m.entrySet()) {
+            if (pair.getValue() == null)
+                pair.setValue("");
+        }
+        return m;
+    }
+
+    @Override
+    public String toString() {
+        return "UserSettings{" +
+                "id=" + id +
+                ", userid=" + userID +
+                ", fileNameForExport='" + fileNameForExport + '\'' +
+                ", leftContextItemForExport='" + leftContextItemForExport + '\''
+                +
+                ", leftContextSizeForExport=" + leftContextSizeForExport +
+                ", locale='" + locale + '\'' +
+                ", leftContextItem='" + leftContextItem + '\'' +
+                ", leftContextSize=" + leftContextSize +
+                ", rightContextItem='" + rightContextItem + '\'' +
+                ", rightContextItemForExport='" + rightContextItemForExport
+                + '\'' +
+                ", rightContextSize=" + rightContextSize +
+                ", rightContextSizeForExport=" + rightContextSizeForExport +
+                ", selectedCollection='" + selectedCollection + '\'' +
+                ", queryLanguage='" + queryLanguage + '\'' +
+                ", pageLength=" + pageLength +
+                ", metadataQueryExpertModus=" + metadataQueryExpertModus +
+                ", defaultPOSfoundry='" + defaultPOSfoundry + '\'' +
+                ", defaultLemmafoundry='" + defaultLemmafoundry + '\'' +
+                ", defaultConstfoundry='" + defaultConstfoundry + '\'' +
+                ", defaultRelfoundry='" + defaultRelfoundry + '\'' +
+                ", collectData='" + collectData + "\'" +
+                '}';
+    }
+
+    public static UserSettings fromString(String value) {
+        Map<String, Object> map;
+        try {
+            map = JsonUtils.read(value, Map.class);
+        }catch (IOException e) {
+            return new UserSettings();
+        }
+        return UserSettings.fromObjectMap(map);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+
+        UserSettings that = (UserSettings) o;
+
+        if (userID != null ? userID != that.userID : that.userID != null)
+            return false;
+        if (id != null ? !id.equals(that.id) : that.id != null)
+            return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = id != null ? id.hashCode() : 0;
+        result = 31 * result + (userID != null ? userID.hashCode() : 0);
+        return result;
+    }
+
+    public String toJSON() {
+        return JsonUtils.toJSON(this);
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/Benchmark.java b/src/main/java/de/ids_mannheim/korap/utils/Benchmark.java
new file mode 100644
index 0000000..1f06897
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/Benchmark.java
@@ -0,0 +1,15 @@
+package de.ids_mannheim.korap.utils;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author hanl
+ * @date 29/04/2014
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+public @interface Benchmark {
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/BooleanUtils.java b/src/main/java/de/ids_mannheim/korap/utils/BooleanUtils.java
new file mode 100644
index 0000000..2e767ed
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/BooleanUtils.java
@@ -0,0 +1,23 @@
+package de.ids_mannheim.korap.utils;
+
+/**
+ * @author hanl
+ * @date 19/02/2014
+ */
+public class BooleanUtils {
+
+    public static String dbname;
+
+    public static Object getBoolean(Object val) {
+        if (val == null) val = false;
+        if (dbname != null
+                && dbname.equalsIgnoreCase("sqlite")) {
+            if (val instanceof Boolean) {
+                return (val == true) ? 1 : 0;
+            } else if (val instanceof Integer) {
+                return ((Integer) val == 1);
+            }
+        }
+        return val;
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/CollectionQueryBuilder.java b/src/main/java/de/ids_mannheim/korap/utils/CollectionQueryBuilder.java
new file mode 100644
index 0000000..b68feac
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/CollectionQueryBuilder.java
@@ -0,0 +1,319 @@
+package de.ids_mannheim.korap.utils;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multiset;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author hanl
+ * @date 06/12/2013
+ */
+@Deprecated
+public class CollectionQueryBuilder {
+
+    private enum Relation {
+        OR, AND
+    }
+
+    private CollectionTypes types;
+    private List<Map> rq;
+    private Multimap<String, String> mfilter;
+    private Multimap<String, String> mextension;
+    private Relation simpleFilterRel = Relation.OR;
+    private Relation simpleExtendRel = Relation.OR;
+
+
+    public CollectionQueryBuilder() {
+        this.rq = new ArrayList<>();
+        this.mfilter = ArrayListMultimap.create();
+        this.mextension = ArrayListMultimap.create();
+        this.types = new CollectionTypes();
+    }
+
+    public CollectionQueryBuilder addResource(String query) {
+        try {
+            List v = JsonUtils.read(query, LinkedList.class);
+            this.rq.addAll(v);
+        } catch (IOException e) {
+            throw new IllegalArgumentException("Conversion went wrong!");
+        }
+        return this;
+    }
+
+    public CollectionQueryBuilder addResources(List<String> queries) {
+        for (String query : queries)
+            addResource(query);
+        return this;
+    }
+
+    public CollectionQueryBuilder addMetaFilter(String key, String value) {
+        this.mfilter.put(key, value);
+        return this;
+    }
+
+
+    public CollectionQueryBuilder addMetaFilterQuery(String queries) {
+        this.mfilter.putAll(resRel(queries));
+        return this;
+    }
+
+    public CollectionQueryBuilder addMetaExtend(String key, String value) {
+        this.mextension.put(key, value);
+        return this;
+    }
+
+
+    public CollectionQueryBuilder setFilterAttributeRelation(Relation rel) {
+        simpleFilterRel = rel;
+        return this;
+    }
+
+
+    public CollectionQueryBuilder setExtendAttributeRelation(Relation rel) {
+        simpleExtendRel = rel;
+        return this;
+    }
+
+    public CollectionQueryBuilder addMetaExtendQuery(String queries) {
+        this.mextension.putAll(resRel(queries));
+        return this;
+    }
+
+
+    @Deprecated
+    private List<Map> createFilter(Relation rel) {
+        String relation = rel == Relation.AND ? "and" : "or";
+        List<Map> mfil = new ArrayList<>();
+        boolean multypes = this.mfilter.keySet().size() > 1;
+        String def_key = null;
+
+        if (!multypes) {
+            Multiset<String> keys = this.mfilter.keys();
+            def_key = keys.toArray(new String[keys.size()])[0];
+        }
+
+        List value = this.createValue(this.mfilter);
+
+        if (mfilter.values().size() == 1)
+            Collections.addAll(mfil, types.createMetaFilter((Map) value.get(0)));
+        else {
+            Map group;
+            if (!multypes)
+                group = types.createGroup(relation, def_key, value);
+            else
+                group = types.createGroup(relation, null, value);
+            Collections.addAll(mfil, types.createMetaFilter(group));
+        }
+        return mfil;
+    }
+
+    @Deprecated
+    private List<Map> createExtender(Relation rel) {
+        String relation = rel == Relation.AND ? "and" : "or";
+        List<Map> mex = new ArrayList();
+        boolean multypes = this.mextension.keys().size() > 1;
+        String def_key = null;
+
+        if (!multypes)
+            def_key = this.mextension.keys().toArray(new String[0])[0];
+
+        List value = this.createValue(this.mextension);
+        // todo: missing: - takes only one resource, but resources can be chained!
+        if (this.mextension.values().size() == 1)
+            Collections.addAll(mex, types.createMetaExtend((Map) value.get(0)));
+        else {
+            Map group;
+            if (!multypes)
+                group = types.createGroup(relation, def_key, value);
+            else
+                group = types.createGroup(relation, null, value);
+            Collections.addAll(mex, types.createMetaExtend(group));
+        }
+        return mex;
+    }
+
+    private List<Map> join() {
+        List<Map> cursor = new ArrayList<>(this.rq);
+        if (!this.mfilter.isEmpty())
+            cursor.addAll(this.createFilter(simpleFilterRel));
+        if (!this.mextension.isEmpty())
+            cursor.addAll(this.createExtender(simpleExtendRel));
+        return cursor;
+    }
+
+    private List createValue(Multimap<String, String> map) {
+        List value = new ArrayList<>();
+        String[] dates = new String[3];
+        for (String key : map.keySet()) {
+            if (key.equals("pubDate")) {
+                dates = processDates((List<String>) map.get(key));
+                continue;
+            }
+
+            if (map.get(key).size() == 1) {
+                Map term = types.createTerm(key, null,
+                        map.get(key).toArray(new String[0])[0], null);
+                value.add(term);
+            } else {
+                boolean multypes = map.keySet().size() > 1;
+                List g = new ArrayList();
+                for (String v : map.get(key))
+                    g.add(types.createTerm(null, v, null));
+
+                if (multypes) {
+                    Map group = types.createGroup("and", key, g);
+                    value.add(group);
+                } else
+                    value.addAll(g);
+
+            }
+        }
+
+        int idx = 3;
+        if (dates[0] != null && dates[0].equals("r")) {
+            Map term1 = types.createTerm(null, dates[1], "korap:date");
+            Map term2 = types.createTerm(null, dates[2], "korap:date");
+            Map group = types.createGroup("between", "pubDate", Arrays.asList(term1, term2));
+            value.add(group);
+        } else if (dates[1] != null) {
+            Map term1 = types.createTerm(null, dates[1], "korap:date");
+            Map group = types.createGroup("since", "pubDate", Arrays.asList(term1));
+            value.add(group);
+        } else if (dates[2] != null) {
+            Map term1 = types.createTerm(null, dates[2], "korap:date");
+            Map group = types.createGroup("until", "pubDate", Arrays.asList(term1));
+            value.add(group);
+        }
+
+        for (int i = idx; i < dates.length; i++) {
+            if (dates[i] != null) {
+                Map term1 = types.createTerm(dates[i], "korap:date");
+                Map group = types.createGroup("exact", "pubDate", Arrays.asList(term1));
+                value.add(group);
+            }
+        }
+        return value;
+    }
+
+    private String[] processDates(List<String> dates) {
+        if (dates.isEmpty())
+            return new String[3];
+        String[] el = new String[dates.size() + 3];
+        int idx = 3;
+        for (String value : dates) {
+            if (value.contains("<")) {
+                String[] sp = value.split("<");
+                el[1] = sp[1];
+            } else if (value.contains(">")) {
+                String[] sp = value.split(">");
+                el[2] = sp[1];
+            } else {
+                el[idx] = value;
+                idx++;
+            }
+        }
+        if (el[1] != null && el[2] != null)
+            el[0] = "r";
+        return el;
+    }
+
+    public List<Map> raw() {
+        return join();
+    }
+
+    public String toCollections() {
+        Map meta = new LinkedHashMap();
+        meta.put("collections", join());
+        return JsonUtils.toJSON(meta);
+    }
+
+    /**
+     * returns all references to parents and meta query as string representation
+     *
+     * @return
+     */
+    public JsonNode toNode() {
+        return JsonUtils.valueToTree(join());
+    }
+
+    public String toJSON() {
+        return JsonUtils.toJSON(join());
+    }
+
+
+    /**
+     * resolves all queries as equal (hierarchy) AND/OR relations
+     * grouping is not supported!
+     *
+     * @param queries
+     * @return
+     */
+    private Multimap<String, String> resRel(String queries) {
+        Multimap<String, String> qmap = ArrayListMultimap.create();
+        String op = null;
+        if (queries.contains("AND") | queries.contains("OR"))
+            op = queries.contains("AND") ? "AND" : "OR";
+        else if (queries.contains("&") | queries.contains("|"))
+            op = queries.contains("&") ? "&" : "|";
+
+        if (op == null)
+            return qmap;
+
+        String[] spl = queries.trim().split(op);
+        for (String query : spl) {
+            String[] q = query.split("=");
+            if (q.length > 1) {
+                String attr = q[0].trim();
+                String val = q[1].trim();
+                qmap.put(attr, val);
+            }
+            // todo: return error when query not well-formed
+        }
+        return qmap;
+    }
+
+    /**
+     * resolve relations and allow grouping of attributes: (tc1 and tc1) or (tc3)
+     *
+     * @param queries
+     * @param filter  flag if either filter or extend collection
+     * @return
+     */
+    private void resRelation(String queries, boolean filter) {
+        Pattern p = Pattern.compile("\\(([\\w\\s:]+)\\)");
+        List _fill = new ArrayList();
+        Matcher m = p.matcher(queries);
+        while (m.find()) {
+            String gr = m.group(1);
+            _fill.add(gr);
+            String whole = "(" + gr + ")";
+            int fin = queries.lastIndexOf(whole);
+            String sub = queries.substring(queries.indexOf(whole), queries.lastIndexOf(whole));
+            queries.replace(whole, "");
+        }
+    }
+
+    private void v(String queries, boolean filter) {
+        // and exclude sub-groups?? : ((tc=121))
+        Pattern p = Pattern.compile("\\(([\\w\\s=]+)\\)");
+        List _fill = new ArrayList();
+        Matcher m = p.matcher(queries);
+        while (m.find()) {
+            String gr = m.group(1);
+
+        }
+
+    }
+
+    public void clear() {
+        this.rq.clear();
+        this.mfilter.clear();
+        this.mextension.clear();
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/CollectionQueryBuilder2.java b/src/main/java/de/ids_mannheim/korap/utils/CollectionQueryBuilder2.java
new file mode 100644
index 0000000..1058f5b
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/CollectionQueryBuilder2.java
@@ -0,0 +1,86 @@
+package de.ids_mannheim.korap.utils;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+import java.io.IOException;
+import java.util.*;
+
+/**
+ * @author hanl
+ * @date 13/05/2014
+ */
+@Deprecated
+public class CollectionQueryBuilder2 {
+
+    private List<Map> rq;
+    private Map groups;
+    private CollectionTypes types;
+    private boolean verbose;
+
+    public CollectionQueryBuilder2() {
+        this.verbose = false;
+        this.rq = new ArrayList<>();
+        this.groups = new HashMap();
+        this.types = new CollectionTypes();
+    }
+
+    public CollectionQueryBuilder2(boolean verbose) {
+        this();
+        this.verbose = verbose;
+    }
+
+
+    public CollectionQueryBuilder2 addResource(String collections) {
+        try {
+            List v = JsonUtils.read(collections, LinkedList.class);
+            this.rq.addAll(v);
+        } catch (IOException e) {
+            throw new IllegalArgumentException("Conversion went wrong!");
+        }
+        return this;
+    }
+
+    public CollectionQueryBuilder2 addResources(List<String> queries) {
+        for (String query : queries)
+            addResource(query);
+        return this;
+    }
+
+//    public CollectionQueryBuilder2 setQuery(String query) {
+//        CollectionQueryProcessor tree = new CollectionQueryProcessor();
+//        tree.process(query);
+//        this.groups = tree.getRequestMap();
+//        return this;
+//    }
+
+    public List raw() {
+        List list = new ArrayList(this.rq);
+        list.add(types.createMetaFilter(this.groups));
+        return list;
+    }
+
+    private Object raw2() {
+        return this.groups;
+    }
+
+    public String toCollections() {
+        Map value = new HashMap();
+        value.put("collections", raw2());
+        return JsonUtils.toJSON(value);
+    }
+
+    public JsonNode toNode() {
+        return JsonUtils.valueToTree(raw2());
+    }
+
+    public String toJSON() {
+        return JsonUtils.toJSON(raw2());
+    }
+
+
+    // add public filter to original query
+    private void addToGroup() {
+        Map first = this.rq.get(0);
+
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/CollectionQueryBuilder3.java b/src/main/java/de/ids_mannheim/korap/utils/CollectionQueryBuilder3.java
new file mode 100644
index 0000000..1217085
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/CollectionQueryBuilder3.java
@@ -0,0 +1,79 @@
+package de.ids_mannheim.korap.utils;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * convenience builder class for collection query -- new one
+ *
+ * @author hanl
+ * @date 16/09/2014
+ */
+public class CollectionQueryBuilder3 {
+
+    private boolean verbose;
+    private List<Map> rq;
+    private StringBuilder builder;
+
+    public CollectionQueryBuilder3() {
+        this(false);
+    }
+
+    public CollectionQueryBuilder3(boolean verbose) {
+        this.verbose = verbose;
+        this.builder = new StringBuilder();
+        this.rq = new LinkedList<>();
+    }
+
+
+    public CollectionQueryBuilder3 addSegment(String field, String value) {
+        String f = field + "=" + value;
+        this.builder.append(f);
+        return this;
+    }
+
+    public CollectionQueryBuilder3 add(String query) {
+        this.builder.append(query);
+        return this;
+    }
+
+    public CollectionQueryBuilder3 and() {
+        this.builder.append(" & ");
+        return this;
+    }
+
+    public CollectionQueryBuilder3 or() {
+        this.builder.append(" | ");
+        return this;
+    }
+
+    public CollectionQueryBuilder3 addResource(String collection) {
+        try {
+            List v = JsonUtils.read(collection, LinkedList.class);
+            this.rq.addAll(v);
+        } catch (IOException e) {
+            throw new IllegalArgumentException("Conversion went wrong!");
+        }
+        return this;
+    }
+
+    public List getRequest() {
+        List list = new ArrayList();
+        if (!this.rq.isEmpty())
+            list.addAll(this.rq);
+        System.out.println("RAW QUERY " + this.builder.toString());
+//        CollectionQueryProcessor tree = new CollectionQueryProcessor(this.verbose);
+//        tree.process(this.builder.toString());
+//        list.add(tree.getRequestMap());
+        return list;
+    }
+
+    public String toJSON() {
+        return JsonUtils.toJSON(getRequest());
+    }
+
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/CollectionTypes.java b/src/main/java/de/ids_mannheim/korap/utils/CollectionTypes.java
new file mode 100644
index 0000000..2f90f57
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/CollectionTypes.java
@@ -0,0 +1,95 @@
+package de.ids_mannheim.korap.utils;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import java.io.IOException;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author hanl
+ * @date 04/12/2013
+ */
+public class CollectionTypes {
+
+    private ObjectMapper mapper;
+
+    public CollectionTypes() {
+        this.mapper = new ObjectMapper();
+    }
+
+    public Map createGroup(String relation, String field, List terms) {
+        if (relation == null)
+            return null;
+
+        Map kgroup = new LinkedHashMap<>();
+        kgroup.put("@type", "korap:group");
+        if (field != null)
+            kgroup.put("@field", "korap:field#" + field);
+        kgroup.put("relation", relation);
+        kgroup.put("operands", terms);
+        return kgroup;
+    }
+
+    public Map createTerm(String field, String subtype, String value, String type) {
+        Map term = new LinkedHashMap<>();
+        if (type == null)
+            type = "korap:term";
+        term.put("@type", type);
+        if (field != null)
+            term.put("@field", "korap:field#" + field);
+        if (subtype != null)
+            term.put("@subtype", "korap:value#" + subtype);
+        term.put("@value", value);
+        return term;
+    }
+
+    public Map createTerm(String field, String value, String type) {
+        return createTerm(field, null, value, type);
+    }
+
+    public Map createTerm(String field, String value) {
+        return createTerm(field, value, null);
+    }
+
+    public Map createResourceFilter(String resource, Map value) {
+        Map meta = new LinkedHashMap();
+        meta.put("@type", "korap:meta-filter");
+        meta.put("@id", "korap-filter#" + resource);
+        meta.put("@value", value);
+        return meta;
+    }
+
+    public Map createResourceFilter(String resource, String value) throws IOException {
+        return createResourceFilter(resource, mapify(value));
+    }
+
+    public Map createResourceExtend(String resource, Map value) {
+        Map meta = new LinkedHashMap();
+        meta.put("@type", "korap:meta-extend");
+        meta.put("@id", "korap-filter#" + resource);
+        meta.put("@value", value);
+        return meta;
+    }
+
+    public Map createMetaFilter(Map value) {
+        Map meta = new LinkedHashMap();
+        meta.put("@type", "korap:meta-filter");
+        meta.put("@value", value);
+        return meta;
+    }
+
+    public Map createMetaExtend(Map value) {
+        Map meta = new LinkedHashMap();
+        meta.put("@type", "korap:meta-extend");
+        meta.put("@value", value);
+        return meta;
+    }
+
+
+    public Map mapify(String s) throws IOException {
+        return mapper.readValue(s, Map.class);
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/ConcurrentMultiMap.java b/src/main/java/de/ids_mannheim/korap/utils/ConcurrentMultiMap.java
new file mode 100644
index 0000000..5bb811e
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/ConcurrentMultiMap.java
@@ -0,0 +1,132 @@
+package de.ids_mannheim.korap.utils;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.MapMaker;
+
+import java.util.List;
+import java.util.concurrent.ConcurrentMap;
+
+import com.google.common.collect.Sets;
+
+import java.util.Collection;
+import java.util.Set;
+
+
+/**
+ * A general purpose Multimap implementation for delayed processing and concurrent insertion/deletes.
+ * This code is based on an implementation by Guido Medina!
+ *
+ * @param <K> A comparable Key
+ * @param <V> A comparable Value
+ */
+
+/**
+ * User: hanl
+ * Date: 8/27/13
+ * Time: 11:18 AM
+ */
+
+public class ConcurrentMultiMap<K extends Comparable, V extends Comparable> {
+
+    private final int initialCapacity;
+    private final LockMap<K> locks;
+    private final ConcurrentMap<K, List<V>> cache;
+
+    public ConcurrentMultiMap() {
+        this(16, 64);
+    }
+
+    public ConcurrentMultiMap(final int concurrencyLevel) {
+        this(concurrencyLevel, 64);
+    }
+
+    public ConcurrentMultiMap(final int concurrencyLevel, final int initialCapacity) {
+        this.initialCapacity = initialCapacity;
+        cache = new MapMaker().concurrencyLevel(concurrencyLevel).initialCapacity(initialCapacity).makeMap();
+        locks = new LockMap<K>(concurrencyLevel, initialCapacity);
+    }
+
+    public void put(final K key, final V value) {
+        synchronized (locks.getLock(key)) {
+            List<V> set = cache.get(key);
+            if (set == null) {
+                set = Lists.newArrayListWithExpectedSize(initialCapacity);
+                cache.put(key, set);
+            }
+            set.add(value);
+        }
+    }
+
+    public void putAll(final K key, final Collection<V> values) {
+        synchronized (locks.getLock(key)) {
+            List<V> set = cache.get(key);
+            if (set == null) {
+                set = Lists.newArrayListWithExpectedSize(initialCapacity);
+                cache.put(key, set);
+            }
+            set.addAll(values);
+        }
+    }
+
+    public List<V> remove(final K key) {
+        synchronized (locks.getLock(key)) {
+            return cache.remove(key);
+        }
+    }
+
+
+    public void remove(final K key, final V value) {
+        List<V> values = cache.get(key);
+        synchronized (locks.getLock(key)) {
+            values.remove(value);
+        }
+    }
+
+
+    public Set<K> getKeySet() {
+        return cache.keySet();
+    }
+
+    public int size() {
+        return cache.size();
+    }
+
+    public boolean containsKey(K key) {
+        return cache.containsKey(key);
+    }
+
+    public List<V> get(K key) {
+        return cache.get(key);
+    }
+
+
+    public class LockMap<K extends Comparable> {
+        private final ConcurrentMap<K, Object> locks;
+
+        public LockMap() {
+            this(16, 64);
+        }
+
+        public LockMap(final int concurrencyLevel) {
+            this(concurrencyLevel, 64);
+        }
+
+        public LockMap(final int concurrencyLevel, final int initialCapacity) {
+            locks = new MapMaker().concurrencyLevel(concurrencyLevel).initialCapacity(initialCapacity).weakValues().makeMap();
+        }
+
+        public Object getLock(final K key) {
+            final Object object = new Object();
+            Object lock = locks.putIfAbsent(key, object);
+            return lock == null ? object : lock;
+        }
+
+    }
+
+
+    public String toString() {
+        return cache.toString();
+    }
+
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/JsonUtils.java b/src/main/java/de/ids_mannheim/korap/utils/JsonUtils.java
new file mode 100644
index 0000000..85c7e3e
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/JsonUtils.java
@@ -0,0 +1,93 @@
+package de.ids_mannheim.korap.utils;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author hanl
+ * @date 28/01/2014
+ */
+public class JsonUtils {
+    private static ObjectMapper mapper = new ObjectMapper();
+
+    private JsonUtils() {
+    }
+
+    public static String toJSON(Object values) {
+        try {
+            return mapper.writeValueAsString(values);
+        }catch (JsonProcessingException e) {
+            return "";
+        }
+    }
+
+    public static JsonNode readTree(String s) {
+        try {
+            return mapper.readTree(s);
+        }catch (IOException e) {
+            return null;
+        }
+    }
+
+    public static ObjectNode createObjectNode() {
+        return mapper.createObjectNode();
+    }
+
+    public static ArrayNode createArrayNode() {
+        return mapper.createArrayNode();
+    }
+
+    public static JsonNode valueToTree(Object value) {
+        return mapper.valueToTree(value);
+    }
+
+    public static <T> T read(String json, Class<T> cl) throws IOException {
+        return mapper.readValue(json, cl);
+    }
+
+    public static <T> T readFile(String path, Class<T> clazz)
+            throws IOException {
+        return mapper.readValue(new File(path), clazz);
+    }
+
+    public static void writeFile(String path, String content) throws IOException {
+        mapper.writeValue(new File(path), content);
+    }
+
+    public static <T> T readSimple(String json, Class<T> cl) {
+        try {
+            return mapper.readValue(json, cl);
+        }catch (IOException e) {
+            return null;
+        }
+    }
+
+    public static List<Map<String, Object>> convertToList(String json)
+            throws JsonProcessingException {
+        List d = new ArrayList();
+        JsonNode node = JsonUtils.readTree(json);
+        if (node.isArray()) {
+            Iterator<JsonNode> nodes = node.iterator();
+            while (nodes.hasNext()) {
+                Map<String, Object> map = mapper
+                        .treeToValue(nodes.next(), Map.class);
+                d.add(map);
+            }
+        }else if (node.isObject()) {
+            Map<String, Object> map = mapper.treeToValue(node, Map.class);
+            d.add(map);
+        }
+        return d;
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/KorAPLogger.java b/src/main/java/de/ids_mannheim/korap/utils/KorAPLogger.java
new file mode 100644
index 0000000..5fc876f
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/KorAPLogger.java
@@ -0,0 +1,373 @@
+package de.ids_mannheim.korap.utils;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.Marker;
+
+/**
+ * @author hanl
+ * @date 28/03/2014
+ */
+
+public class KorAPLogger implements Logger {
+    // debugging flag, info, warn, error will always be logged though!
+    public static boolean DEBUG = false;
+
+    public static final String ERROR_LOG = "errorLog";
+    public static final String SECURITY_LOG = "securityLog";
+
+    //fixme:
+    public static final KorAPLogger ERROR_LOGGER = KorAPLogger
+            .initiate(ERROR_LOG);
+    public static final KorAPLogger QUERY_LOGGER = KorAPLogger.initiate("ql");
+
+    @Deprecated
+    public static final KorAPLogger SECURITY_LOGGER = KorAPLogger
+            .initiate("security");
+    private Logger log;
+
+    public static KorAPLogger initiate(Class cl) {
+        KorAPLogger l = new KorAPLogger();
+        l.log = LoggerFactory.getLogger(cl);
+        return l;
+    }
+
+    public static KorAPLogger initiate(String name) {
+        KorAPLogger l = new KorAPLogger();
+        l.log = LoggerFactory.getLogger(name);
+        return l;
+    }
+
+    private KorAPLogger() {
+    }
+
+    @Override
+    public String getName() {
+        return log.getName();
+    }
+
+    @Override
+    public boolean isTraceEnabled() {
+        return log.isTraceEnabled();
+    }
+
+    @Override
+    public void trace(String s) {
+        if (DEBUG)
+            this.log.trace(s);
+
+    }
+
+    @Override
+    public void trace(String s, Object o) {
+        if (DEBUG)
+            this.log.trace(s, o);
+    }
+
+    @Override
+    public void trace(String s, Object o, Object o2) {
+        if (DEBUG)
+            this.log.trace(s, o, o2);
+    }
+
+    @Override
+    public void trace(String s, Object... objects) {
+        if (DEBUG)
+            this.log.trace(s, objects);
+    }
+
+    @Override
+    public void trace(String s, Throwable throwable) {
+        if (DEBUG)
+            this.log.trace(s, throwable);
+    }
+
+    @Override
+    public boolean isTraceEnabled(Marker marker) {
+        if (DEBUG)
+            return true;
+        return false;
+    }
+
+    @Override
+    public void trace(Marker marker, String s) {
+        if (DEBUG)
+            this.log.trace(marker, s);
+    }
+
+    @Override
+    public void trace(Marker marker, String s, Object o) {
+        if (DEBUG)
+            this.log.trace(marker, s, o);
+    }
+
+    @Override
+    public void trace(Marker marker, String s, Object o, Object o2) {
+        if (DEBUG)
+            this.log.trace(marker, s, o, o2);
+    }
+
+    @Override
+    public void trace(Marker marker, String s, Object... objects) {
+        if (DEBUG)
+            this.log.trace(marker, s, objects);
+    }
+
+    @Override
+    public void trace(Marker marker, String s, Throwable throwable) {
+        if (DEBUG)
+            this.log.trace(marker, s, throwable);
+    }
+
+    @Override
+    public boolean isDebugEnabled() {
+        if (DEBUG)
+            return true;
+        return false;
+    }
+
+    @Override
+    public void debug(String s) {
+        if (DEBUG)
+            this.log.debug(s);
+    }
+
+    @Override
+    public void debug(String s, Object o) {
+        if (DEBUG)
+            this.log.debug(s, o);
+    }
+
+    @Override
+    public void debug(String s, Object o, Object o2) {
+        if (DEBUG)
+            this.log.debug(s, o, o2);
+    }
+
+    @Override
+    public void debug(String s, Object... objects) {
+        if (DEBUG)
+            this.log.debug(s);
+    }
+
+    @Override
+    public void debug(String s, Throwable throwable) {
+        if (DEBUG)
+            this.log.debug(s, throwable);
+    }
+
+    @Override
+    public boolean isDebugEnabled(Marker marker) {
+        return this.log.isDebugEnabled(marker);
+    }
+
+    @Override
+    public void debug(Marker marker, String s) {
+        if (DEBUG)
+            this.log.debug(marker, s);
+    }
+
+    @Override
+    public void debug(Marker marker, String s, Object o) {
+        if (DEBUG)
+            this.log.debug(marker, s, o);
+    }
+
+    @Override
+    public void debug(Marker marker, String s, Object o, Object o2) {
+        if (DEBUG)
+            this.log.debug(marker, s, o, o2);
+    }
+
+    @Override
+    public void debug(Marker marker, String s, Object... objects) {
+        if (DEBUG)
+            this.log.debug(marker, s, objects);
+    }
+
+    @Override
+    public void debug(Marker marker, String s, Throwable throwable) {
+        if (DEBUG)
+            this.log.debug(marker, s, throwable);
+    }
+
+    @Override
+    public boolean isInfoEnabled() {
+        return this.log.isInfoEnabled();
+    }
+
+    @Override
+    public void info(String s) {
+        this.log.info(s);
+    }
+
+    @Override
+    public void info(String s, Object o) {
+        this.log.info(s, o);
+    }
+
+    @Override
+    public void info(String s, Object o, Object o2) {
+        this.log.info(s, o, o2);
+    }
+
+    @Override
+    public void info(String s, Object... objects) {
+        this.log.info(s, objects);
+    }
+
+    @Override
+    public void info(String s, Throwable throwable) {
+        this.log.info(s, throwable);
+    }
+
+    @Override
+    public boolean isInfoEnabled(Marker marker) {
+        return this.log.isInfoEnabled(marker);
+    }
+
+    @Override
+    public void info(Marker marker, String s) {
+        this.log.info(marker, s);
+    }
+
+    @Override
+    public void info(Marker marker, String s, Object o) {
+        this.log.info(marker, s, o);
+    }
+
+    @Override
+    public void info(Marker marker, String s, Object o, Object o2) {
+        this.log.info(marker, s, o, o2);
+    }
+
+    @Override
+    public void info(Marker marker, String s, Object... objects) {
+        this.log.info(marker, s, objects);
+    }
+
+    @Override
+    public void info(Marker marker, String s, Throwable throwable) {
+        this.log.info(marker, s, throwable);
+    }
+
+    @Override
+    public boolean isWarnEnabled() {
+        return this.log.isWarnEnabled();
+    }
+
+    @Override
+    public void warn(String s) {
+        this.log.warn(s);
+    }
+
+    @Override
+    public void warn(String s, Object o) {
+        this.log.warn(s, o);
+    }
+
+    @Override
+    public void warn(String s, Object... objects) {
+        this.log.warn(s, objects);
+    }
+
+    @Override
+    public void warn(String s, Object o, Object o2) {
+        this.log.warn(s, o, o2);
+    }
+
+    @Override
+    public void warn(String s, Throwable throwable) {
+        this.log.warn(s, throwable);
+    }
+
+    @Override
+    public boolean isWarnEnabled(Marker marker) {
+        return this.log.isTraceEnabled(marker);
+    }
+
+    @Override
+    public void warn(Marker marker, String s) {
+        this.log.warn(marker, s);
+    }
+
+    @Override
+    public void warn(Marker marker, String s, Object o) {
+        this.log.warn(marker, s, o);
+    }
+
+    @Override
+    public void warn(Marker marker, String s, Object o, Object o2) {
+        this.log.warn(marker, s, o, o2);
+    }
+
+    @Override
+    public void warn(Marker marker, String s, Object... objects) {
+        this.log.warn(marker, s, objects);
+    }
+
+    @Override
+    public void warn(Marker marker, String s, Throwable throwable) {
+        this.log.warn(marker, s, throwable);
+    }
+
+    @Override
+    public boolean isErrorEnabled() {
+        return this.log.isErrorEnabled();
+    }
+
+    @Override
+    public void error(String s) {
+        this.log.error(s);
+    }
+
+    @Override
+    public void error(String s, Object o) {
+        this.log.error(s, o);
+    }
+
+    @Override
+    public void error(String s, Object o, Object o2) {
+        this.log.error(s, o, o2);
+    }
+
+    @Override
+    public void error(String s, Object... objects) {
+        this.log.error(s, objects);
+    }
+
+    @Override
+    public void error(String s, Throwable throwable) {
+        this.log.error(s, throwable);
+    }
+
+    @Override
+    public boolean isErrorEnabled(Marker marker) {
+        return this.log.isErrorEnabled(marker);
+    }
+
+    @Override
+    public void error(Marker marker, String s) {
+        this.log.error(marker, s);
+    }
+
+    @Override
+    public void error(Marker marker, String s, Object o) {
+        this.log.error(marker, s, o);
+    }
+
+    @Override
+    public void error(Marker marker, String s, Object o, Object o2) {
+        this.log.error(marker, s, o, o2);
+    }
+
+    @Override
+    public void error(Marker marker, String s, Object... objects) {
+        this.log.error(marker, s, objects);
+    }
+
+    @Override
+    public void error(Marker marker, String s, Throwable throwable) {
+        this.log.error(marker, s, throwable);
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/PrefixTreeMap.java b/src/main/java/de/ids_mannheim/korap/utils/PrefixTreeMap.java
new file mode 100644
index 0000000..493a574
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/PrefixTreeMap.java
@@ -0,0 +1,46 @@
+package de.ids_mannheim.korap.utils;
+
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/**
+ * @author hanl
+ * @date 01/07/2014
+ */
+public class PrefixTreeMap<V> extends TreeMap<String, V> {
+
+
+    public SortedMap<String, V> getPrefixSubMap(String prefix) {
+        if (prefix.length() > 0) {
+            SortedMap d = this.subMap(prefix, getEnd(prefix));
+            if (d.isEmpty())
+                return null;
+            return d;
+        }
+        return null;
+    }
+
+    private String getEnd(String prefix) {
+        char nextLetter = (char) (prefix.charAt(prefix.length() - 1) + 1);
+        return prefix.substring(0, prefix.length() - 1) + nextLetter;
+
+    }
+
+    public V getFirstValue(String prefix) {
+        if (prefix.length() > 0) {
+            String first = this.subMap(prefix, getEnd(prefix)).firstKey();
+            return this.get(first);
+        }
+        return null;
+    }
+
+    public V getLastValue(String prefix) {
+        if (prefix.length() > 0) {
+            String last = this.subMap(prefix, getEnd(prefix)).lastKey();
+            return this.get(last);
+        }
+        return null;
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/StringUtils.java b/src/main/java/de/ids_mannheim/korap/utils/StringUtils.java
new file mode 100644
index 0000000..a7120aa
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/StringUtils.java
@@ -0,0 +1,191 @@
+package de.ids_mannheim.korap.utils;
+
+import org.apache.commons.lang3.StringEscapeUtils;
+import org.slf4j.Logger;
+
+import java.util.*;
+
+public class StringUtils {
+    private final static Logger jlog = KorAPLogger.initiate(StringUtils.class);
+
+    private static final String SLASH = "/";
+    private static final String SEP = ";";
+
+    public static Collection<UUID> stringToUUIDList(String s) {
+        String[] array = s.split(SEP);
+        List<UUID> list = new LinkedList<>();
+        for (String att : array) {
+            list.add(UUID.fromString(att));
+        }
+        return list;
+    }
+
+    public static List<String> toList(String values) {
+        List<String> list = new ArrayList<>();
+        StringTokenizer tokenizer = new StringTokenizer(values, SEP);
+        while (tokenizer.hasMoreTokens())
+            list.add(tokenizer.nextToken());
+        return list;
+    }
+
+    public static Set<String> toSet(String values, String sep) {
+        Set<String> set = new HashSet<>();
+        StringTokenizer tokenizer = new StringTokenizer(values, sep);
+        while (tokenizer.hasMoreTokens())
+            set.add(tokenizer.nextToken());
+        return set;
+    }
+
+    public static Set<String> toSet(String values) {
+        return toSet(values, SEP);
+    }
+
+    public static String toString(Collection<String> values) {
+        return StringUtils.toString(values, SEP);
+    }
+
+    public static String toString(Collection<String> values, String sep) {
+        StringBuffer b = new StringBuffer();
+        for (String s : values)
+            b.append(s).append(sep);
+
+        if (b.length() > 0)
+            b.deleteCharAt(b.length() - 1);
+        return b.toString();
+    }
+
+    public static String orderedToString(Collection<String> hash) {
+        Set<String> orderedSet = new TreeSet<>();
+        orderedSet.addAll(hash);
+        if (orderedSet.isEmpty()) {
+            return "";
+        }else {
+            StringBuilder builder = new StringBuilder();
+            for (String s : orderedSet) {
+                builder.append(s);
+                builder.append(SEP);
+            }
+            builder.deleteCharAt(builder.length() - 1);
+            return builder.toString();
+        }
+    }
+
+    public static String UUIDsetToString(Collection<UUID> hash) {
+        Set<UUID> orderedSet = new TreeSet<>();
+        orderedSet.addAll(hash);
+        if (orderedSet.isEmpty()) {
+            return "";
+        }else {
+            StringBuilder builder = new StringBuilder();
+            for (UUID s : orderedSet) {
+                builder.append(s);
+                builder.append(SEP);
+            }
+            builder.deleteCharAt(builder.length() - 1);
+            return builder.toString();
+        }
+    }
+
+    public static String buildSQLRegex(String path) {
+        StringBuilder b = new StringBuilder();
+        String[] match = path.split("/");
+        b.append(match[0]);
+        b.append("(" + "/" + match[1] + ")");
+        b.append("*$");
+        return b.toString();
+    }
+
+    public static Collection<String> joinStringSet(Collection<String> source,
+            String other) {
+        Set<String> set = new HashSet<>(source);
+        set.add(other);
+        return set;
+    }
+
+    public static Collection<UUID> joinUUIDSet(Collection<UUID> source,
+            UUID other) {
+        Set<UUID> set = new HashSet<>(source);
+        set.add(other);
+        return set;
+    }
+
+    public static String joinResources(String first, String second) {
+        String res;
+        if (first != null && !first.isEmpty())
+            res = first + SLASH + second;
+        else
+            res = second;
+        return res.replaceAll("\\s", "");
+    }
+
+    public static String[] splitAnnotations(String joined) {
+        String[] spl = joined.split(SLASH);
+        if (spl.length == 2)
+            return spl;
+        else
+            return null;
+    }
+
+    public static String stripTokenType(String token) {
+        int idx = token.lastIndexOf(" ");
+        if (idx == -1)
+            return token;
+        return token.substring(idx).replaceAll("\\s", "");
+    }
+
+    public static String getTokenType(String token) {
+        return token.substring(0, token.lastIndexOf(" ")).replaceAll("\\s", "")
+                .toLowerCase();
+    }
+
+    public static boolean isInteger(String value) {
+        try {
+            Integer.valueOf(value);
+            return true;
+        }catch (IllegalArgumentException e) {
+            // do nothing!
+            return false;
+        }
+    }
+
+    public static String normalize(String value) {
+        return value.trim().toLowerCase();
+    }
+
+    public static String normalizeHTML(String value) {
+        return StringEscapeUtils.escapeHtml4(value);
+    }
+
+    public static String decodeHTML(String value) {
+        return StringEscapeUtils.unescapeHtml4(value);
+    }
+
+    /**
+     * constructs a lucene query from query string and corpus parameters as set
+     *
+     * @param query
+     * @param corpusIDs
+     * @return
+     */
+    public static String queryBuilder(String query,
+            Collection<String> corpusIDs) {
+        String completeQuery; // holds original query and corpus
+        // selection
+        /**
+         * find documents with metadataquery TODO: does not intercept with
+         * parameters foundries and corpusIDs
+         */
+
+        /* add corpus ids to corpus query */
+        StringBuilder corpusQuery = new StringBuilder("corpus:/(");
+        for (String corpusId : corpusIDs) {
+            corpusQuery.append(corpusId + "|");
+        }
+        corpusQuery.deleteCharAt(corpusQuery.length() - 1);
+        corpusQuery.append(")/");
+        completeQuery = "(" + query + ") AND " + corpusQuery.toString();
+        jlog.debug("Searching documents matching '" + completeQuery + "'.");
+        return completeQuery;
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/utils/TimeUtils.java b/src/main/java/de/ids_mannheim/korap/utils/TimeUtils.java
new file mode 100644
index 0000000..b4f1d30
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/utils/TimeUtils.java
@@ -0,0 +1,207 @@
+package de.ids_mannheim.korap.utils;
+
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+import org.joda.time.LocalDate;
+import org.joda.time.format.DateTimeFormatter;
+import org.joda.time.format.ISODateTimeFormat;
+import org.slf4j.Logger;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * @author hanl
+ *         <p/>
+ *         calculates current, expiration and inactive time for security
+ *         purposes.
+ * @return
+ */
+public class TimeUtils {
+
+    private static DecimalFormat df = new DecimalFormat("#.#############");
+    private static final DateTimeZone dtz = DateTimeZone.forID("Europe/Berlin");
+    private static Logger jlog = KorAPLogger.initiate(TimeUtils.class);
+
+    public static int convertTimeToSeconds(String expirationVal) {
+        expirationVal = expirationVal.trim();
+        int finIndex = expirationVal.length() - 1;
+        char entity = expirationVal.charAt(finIndex);
+        int returnSec = Integer.valueOf(expirationVal.substring(0, finIndex));
+        jlog.debug("setting time value to {} with time in {}", returnSec,
+                entity);
+        switch (entity) {
+            case 'D':
+                return returnSec * 60 * 60 * 24;
+            case 'H':
+                return returnSec * 60 * 60;
+            case 'M':
+                return returnSec * 60;
+            case 'S':
+                return returnSec;
+            default:
+                jlog.debug(
+                        "no time unit specified. Trying to read from default (minutes)");
+                return Integer.valueOf(expirationVal) * 60;
+        }
+
+    }
+
+    //todo: time zone is wrong!
+    public static DateTime getNow() {
+        return DateTime.now().withZone(dtz);
+    }
+
+    //returns difference in milliseconds
+    public static long calcDiff(DateTime now, DateTime future) {
+        long diff = (future.withZone(dtz).getMillis() - now.withZone(dtz)
+                .getMillis());
+        return diff;
+    }
+
+    public static boolean isPassed(long time) {
+        return getNow().isAfter(time);
+
+    }
+
+    public static boolean isPassed(DateTime time) {
+        return isPassed(time.getMillis());
+    }
+
+    // returns difference in seconds in floating number
+    public static float floating(DateTime past, DateTime now) {
+        long diff = (now.withZone(dtz).getMillis() - past.withZone(dtz)
+                .getMillis());
+        double fin = diff / 1000.0;
+        BigDecimal bd = new BigDecimal(fin).setScale(8, RoundingMode.HALF_EVEN);
+        return bd.floatValue();
+    }
+
+    public static DateTime fromCosmas(String date) {
+        int idx = date.length();
+        try {
+            Integer sec = Integer.valueOf(
+                    date.substring((idx = idx - 2), date.length()).trim());
+            Integer min = Integer
+                    .valueOf(date.substring((idx = idx - 2), idx + 2).trim());
+            Integer hours = Integer
+                    .valueOf(date.substring((idx = idx - 2), idx + 2).trim());
+            Integer day = Integer
+                    .valueOf(date.substring((idx = idx - 2), idx + 2).trim());
+            Integer month = Integer
+                    .valueOf(date.substring((idx = idx - 2), idx + 2).trim());
+            Integer year = Integer
+                    .valueOf(date.substring((idx = idx - 4), idx + 4).trim());
+            return new DateTime(year, month, day, hours, min, sec);
+        }catch (NumberFormatException e) {
+            return getNow().toDateTime();
+        }
+    }
+
+    public static String formatDiff(DateTime now, DateTime after) {
+        return df.format(calcDiff(now, after));
+    }
+
+    /**
+     * converts time to the ISO8601 standard.
+     *
+     * @param time
+     * @return
+     */
+    public static String format(DateTime time) {
+        DateTimeFormatter fmt = ISODateTimeFormat.dateTime();
+        return fmt.print(time);
+    }
+
+    public static String format(long time) {
+        DateTimeFormatter fmt = ISODateTimeFormat.dateTime();
+        return fmt.print(time);
+    }
+
+    /**
+     * calculate expiration time
+     *
+     * @param creation
+     * @param plus     time in seconds
+     * @return
+     */
+    public static DateTime plusSeconds(long creation, int plus) {
+        return new DateTime(creation).withZone(dtz).plusSeconds(plus);
+    }
+
+    public static DateTime getExpiration(long now, int exp) {
+        return new DateTime(now).withZone(dtz).plusSeconds(exp);
+    }
+
+    /**
+     * @param plus
+     * @return
+     */
+    public static DateTime plusSeconds(int plus) {
+        return getNow().withZone(dtz).plusSeconds(plus);
+    }
+
+    public static DateTime plusHours(int hours) {
+        return getNow().withZone(dtz).plusHours(hours);
+    }
+
+    public static DateTime plusMinutes(int minutes) {
+        return getNow().withZone(dtz).plusMinutes(minutes);
+    }
+
+    /**
+     * create time stamp from long value
+     *
+     * @param t time
+     * @return Timestamp
+     */
+    public static LocalDate getTimeStamp(long t) {
+        return new DateTime(t).withZone(dtz).toLocalDate();
+    }
+
+    public static DateTime getDate(int day, int month, int year) {
+        DateTime date = new DateTime().withZone(dtz);
+        return date.withDate(year, month, day);
+    }
+
+    public static String toString(long val, Locale locale) {
+        if (locale == Locale.GERMAN)
+            return new DateTime(val)
+                    .toString("dd. MMMM yyyy, HH:mm", Locale.GERMAN);
+        else
+            return new DateTime(val)
+                    .toString("MM-dd-yyyy, hh:mm", Locale.ENGLISH);
+
+    }
+
+    public static String dateToString(long val, int i) {
+        switch (i) {
+            case 1:
+                return new DateTime(val).toString("yyyy-MM");
+            case 2:
+                return new DateTime(val).toString("yyyy-MM-dd");
+            default:
+                return new DateTime(val).toString("yyyy");
+        }
+    }
+
+    private static final List<DateTime> times = new ArrayList<>();
+
+    @Deprecated
+    public static float benchmark(boolean getFinal) {
+        float value = 0;
+        times.add(getNow());
+        if (getFinal && times.size() > 1) {
+            value = floating(times.get(0), times.get(times.size() - 1));
+            times.clear();
+        }else if (times.size() > 1)
+            value = floating(times.get(times.size() - 2),
+                    times.get(times.size() - 1));
+        return value;
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/web/.DS_Store b/src/main/java/de/ids_mannheim/korap/web/.DS_Store
new file mode 100644
index 0000000..32f11f9
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/web/.DS_Store
Binary files differ
diff --git a/src/main/java/de/ids_mannheim/korap/web/ClientsHandler.java b/src/main/java/de/ids_mannheim/korap/web/ClientsHandler.java
new file mode 100644
index 0000000..8b846eb
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/web/ClientsHandler.java
@@ -0,0 +1,52 @@
+package de.ids_mannheim.korap.web;
+
+import com.sun.jersey.api.client.Client;
+import com.sun.jersey.api.client.UniformInterfaceException;
+import com.sun.jersey.api.client.WebResource;
+import com.sun.jersey.api.client.config.ClientConfig;
+import com.sun.jersey.api.client.config.DefaultClientConfig;
+import com.sun.jersey.core.util.MultivaluedMapImpl;
+import de.ids_mannheim.korap.exceptions.KorAPException;
+import de.ids_mannheim.korap.exceptions.StatusCodes;
+
+import javax.ws.rs.core.MultivaluedMap;
+import java.net.URI;
+
+/**
+ * @author hanl
+ * @date 10/12/2013
+ */
+// use for Piotr Ps. rest api connection
+public class ClientsHandler {
+
+    private WebResource service;
+
+    public ClientsHandler(URI address) {
+        ClientConfig config = new DefaultClientConfig();
+        Client client = Client.create(config);
+        this.service = client.resource(address);
+    }
+
+    public String getResponse(String path, String key, Object value) throws KorAPException {
+        MultivaluedMap map = new MultivaluedMapImpl();
+        map.add(key, value);
+        try {
+            return service.path(path).queryParams(map).get(String.class);
+        } catch (UniformInterfaceException e) {
+            throw new KorAPException(StatusCodes.REQUEST_INVALID);
+        }
+    }
+
+    public String getResponse(MultivaluedMap map, String... paths) throws KorAPException {
+        try {
+            WebResource resource = service;
+            for (String p : paths)
+                resource = resource.path(p);
+            resource = resource.queryParams(map);
+            return resource.get(String.class);
+        } catch (UniformInterfaceException e) {
+            throw new KorAPException(StatusCodes.REQUEST_INVALID);
+        }
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/web/Kustvakt.java b/src/main/java/de/ids_mannheim/korap/web/Kustvakt.java
new file mode 100644
index 0000000..f9349e6
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/web/Kustvakt.java
@@ -0,0 +1,54 @@
+package de.ids_mannheim.korap.web;
+
+import com.sun.grizzly.http.embed.GrizzlyWebServer;
+import com.sun.grizzly.http.servlet.ServletAdapter;
+import com.sun.jersey.spi.container.servlet.ServletContainer;
+import de.ids_mannheim.korap.config.BeanConfiguration;
+import de.ids_mannheim.korap.utils.KorAPLogger;
+
+import java.io.IOException;
+
+/**
+ * @author hanl
+ * @date 01/06/2015
+ */
+public class Kustvakt {
+
+    private static Integer PORT = -1;
+
+    public static void main(String[] args) throws Exception {
+        attributes(args);
+        BeanConfiguration.loadContext();
+        grizzlyServer(PORT);
+    }
+
+    public static void grizzlyServer(int port) throws IOException {
+        if (port == -1)
+            port = BeanConfiguration.getConfiguration().getPort();
+        System.out.println("Starting grizzly on port " + port + " ...");
+        GrizzlyWebServer gws = new GrizzlyWebServer(port);
+        ServletAdapter jerseyAdapter = new ServletAdapter();
+        jerseyAdapter
+                .addInitParameter("com.sun.jersey.config.property.packages",
+                        "de.ids_mannheim.korap.web.service");
+        jerseyAdapter.setContextPath("/api");
+        jerseyAdapter.setServletInstance(new ServletContainer());
+
+        gws.addGrizzlyAdapter(jerseyAdapter, new String[] { "/api" });
+        gws.start();
+    }
+
+    private static void attributes(String[] args) {
+        for (int i = 0; i < args.length; i++) {
+            switch ((args[i])) {
+                case "--debug":
+                    KorAPLogger.DEBUG = true;
+                    break;
+                case "--port":
+                    PORT = Integer.valueOf(args[i + 1]);
+                    break;
+            }
+        }
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/web/SearchLucene.java b/src/main/java/de/ids_mannheim/korap/web/SearchLucene.java
new file mode 100644
index 0000000..be19540
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/web/SearchLucene.java
@@ -0,0 +1,313 @@
+// Connector to the Lucene Backend
+package de.ids_mannheim.korap.web;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import de.ids_mannheim.korap.Krill;
+import de.ids_mannheim.korap.KrillCollection;
+import de.ids_mannheim.korap.KrillIndex;
+import de.ids_mannheim.korap.response.Match;
+import de.ids_mannheim.korap.response.Result;
+import de.ids_mannheim.korap.util.QueryException;
+import de.ids_mannheim.korap.utils.JsonUtils;
+import de.ids_mannheim.korap.utils.KorAPLogger;
+import org.apache.lucene.store.MMapDirectory;
+import org.slf4j.Logger;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * The SearchLucene class allows for searching in the Lucene backend
+ * by JSON-LD serialized queries.
+ * It supports span queries, virtual collections, and paging.
+ *
+ * @author Nils Diewald
+ */
+public class SearchLucene {
+    private final static Logger qlog = KorAPLogger.initiate("queryLogger");
+    private final static Logger log = KorAPLogger.initiate(SearchLucene.class);
+    // Temporary
+    String indexDir = "/data/prep_corpus/index/";
+    String i = "/Users/hanl/Projects/prep_corpus";
+    String klinux10 = "/vol/work/hanl/indices";
+
+    private KrillIndex index;
+
+    /**
+     * Constructor
+     */
+    // todo: use korap.config to get index location
+    public SearchLucene(String path) {
+        try {
+            File f = new File(path);
+            log.info("Loading index from " + path);
+            if (!f.exists()) {
+                KorAPLogger.ERROR_LOGGER.error("Index not found!");
+                System.exit(-1);
+            }
+            this.index = new KrillIndex(new MMapDirectory(new File(path)));
+        }catch (IOException e) {
+            KorAPLogger.ERROR_LOGGER
+                    .error("Unable to load index: {}", e.getMessage());
+        }
+    }
+
+    /**
+     * Search in the Lucene index.
+     *
+     * @param json JSON-LD string with search and potential meta filters.
+     */
+    public String search(String json) {
+        qlog.trace(json);
+        if (this.index != null)
+            return new Krill(json).setIndex(this.index).toJsonString();
+
+        Result kr = new Result();
+        //        kr.setError("Index not found");
+        return kr.toJsonString();
+    }
+
+    ;
+
+    /**
+     * Search in the Lucene index and return matches as token lists.
+     *
+     * @param json JSON-LD string with search and potential meta filters.
+     */
+    public String searchTokenList(String json) {
+        qlog.trace(json);
+        if (this.index != null)
+            return new Krill(json).setIndex(this.index).toJsonString();
+
+        Result kr = new Result();
+        //        kr.setError("Index not found");
+        return kr.toJsonString();
+    }
+
+    ;
+
+    /**
+     * Get info on a match - by means of a richly annotated html snippet.
+     *
+     * @param id match id
+     */
+    public String getMatch(String id) {
+
+        if (this.index != null) {
+            try {
+                return this.index.getMatch(id).toJsonString();
+            }catch (QueryException qe) {
+                Match km = new Match();
+                km.setError(qe.getMessage());
+                return km.toJsonString();
+            }
+        }
+
+        Match km = new Match();
+        km.setError("Index not found");
+        return km.toJsonString();
+    }
+
+    public String getMatch(String id, List<String> foundries,
+            List<String> layers, boolean includeSpans,
+            boolean includeHighlights, boolean sentenceExpansion) {
+        if (this.index != null) {
+            try {
+
+                return this.index
+                        .getMatchInfo(id, "tokens", true, foundries, layers,
+                                includeSpans, includeHighlights,
+                                sentenceExpansion).toJsonString();
+            }catch (QueryException qe) {
+                Match km = new Match();
+                km.setError(qe.getMessage());
+                return km.toJsonString();
+            }
+        }
+
+        Match km = new Match();
+        km.setError("Index not found");
+        return km.toJsonString();
+
+    }
+
+    /**
+     * Get info on a match - by means of a richly annotated html snippet.
+     *
+     * @param id                match id
+     * @param foundry           the foundry of interest - may be null
+     * @param layer             the layer of interest - may be null
+     * @param includeSpans      Should spans be included (or only token infos)?
+     * @param includeHighlights Should highlight markup be included?
+     */
+    public String getMatch(String id, String foundry, String layer,
+            boolean includeSpans, boolean includeHighlights,
+            boolean sentenceExpansion) {
+
+        if (this.index != null) {
+            try {
+
+		/*
+          For multiple foundries/layers use
+		  String idString,
+		  "tokens",
+		  true,
+		  ArrayList<String> foundry,
+		  ArrayList<String> layer,
+		  boolean includeSpans,
+		  boolean includeHighlights,
+		  boolean extendToSentence
+		 */
+
+                return this.index.getMatchInfo(id, "tokens", foundry, layer,
+                        includeSpans, includeHighlights, sentenceExpansion)
+                        .toJsonString();
+            }catch (QueryException qe) {
+                Match km = new Match();
+                km.setError(qe.getMessage());
+                return km.toJsonString();
+            }
+        }
+
+        Match km = new Match();
+        km.setError("Index not found");
+        return km.toJsonString();
+    }
+
+    /**
+     * Get statistics on (virtual) collections.
+     *
+     * @param json JSON-LD string with potential meta filters.
+     */
+    public String getStatisticsLegacy(JsonNode json) throws QueryException {
+        qlog.trace(JsonUtils.toJSON(json));
+        System.out.println("THE NODE BEFORE GETTING STATISTICS " + json);
+
+        if (this.index == null) {
+            return "{\"documents\" : -1, error\" : \"No index given\" }";
+        }
+
+        // Create Virtula VCollection from json search
+        KrillCollection kc = new KrillCollection();
+        kc.fromJsonLegacy(json);
+
+        // Set index
+        kc.setIndex(this.index);
+
+        long docs = 0,
+                tokens = 0,
+                sentences = 0,
+                paragraphs = 0;
+
+        // Get numbers from index (currently slow)
+        try {
+            docs = kc.numberOf("documents");
+            tokens = kc.numberOf("tokens");
+            sentences = kc.numberOf("sentences");
+            paragraphs = kc.numberOf("paragraphs");
+        }catch (IOException e) {
+            e.printStackTrace();
+        }
+
+
+	/*
+    KorAPLogger.ERROR_LOGGER.error("Unable to retrieve statistics: {}", e.getMessage());
+	*/
+
+        // Build json response
+        StringBuilder sb = new StringBuilder("{");
+        sb.append("\"documents\":").append(docs).append(",\"tokens\":")
+                .append(tokens).append(",\"sentences\":").append(sentences)
+                .append(",\"paragraphs\":").append(paragraphs).append("}");
+        return sb.toString();
+    }
+
+    /**
+     * Get statistics on (virtual) collections.
+     *
+     * @param json JSON-LD string with potential meta filters.
+     */
+    public String getStatistics(String json) {
+        qlog.trace(json);
+
+        if (this.index == null) {
+            return "{\"documents\" : -1, error\" : \"No index given\" }";
+        }
+
+        // Create Virtual collection from json search
+        KrillCollection kc = new KrillCollection(json);
+
+        // Set index
+        kc.setIndex(this.index);
+
+        long docs = 0,
+                tokens = 0,
+                sentences = 0,
+                paragraphs = 0;
+
+        // Get numbers from index (currently slow)
+        try {
+            docs = kc.numberOf("documents");
+            tokens = kc.numberOf("tokens");
+            sentences = kc.numberOf("sentences");
+            paragraphs = kc.numberOf("paragraphs");
+        }catch (IOException e) {
+            e.printStackTrace();
+        }
+
+
+	/*
+    KorAPLogger.ERROR_LOGGER.error("Unable to retrieve statistics: {}", e.getMessage());
+	*/
+
+        // Build json response
+        StringBuilder sb = new StringBuilder("{");
+        sb.append("\"documents\":").append(docs).append(",\"tokens\":")
+                .append(tokens).append(",\"sentences\":").append(sentences)
+                .append(",\"paragraphs\":").append(paragraphs).append("}");
+        return sb.toString();
+    }
+
+    /**
+     * Get set relations on field terms of (virtual) collections.
+     *
+     * @param json JSON-LD string with potential meta filters.
+     */
+    public String getTermRelation(String json, String field) {
+        qlog.trace(json);
+
+        if (this.index == null) {
+            return "{\"documents\" : -1, \"error\" : \"No index given\" }";
+        }
+
+        // Create Virtula VCollection from json search
+        KrillCollection kc = new KrillCollection(json);
+
+        // Set index
+        kc.setIndex(this.index);
+        long v = 0L;
+        try {
+            v = kc.numberOf("documents");
+        }catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        try {
+            // Get term relations as a json string
+            return kc.getTermRelationJSON(field);
+        }catch (IOException e) {
+            KorAPLogger.ERROR_LOGGER
+                    .error("Unable to retrieve term relations: {}",
+                            e.getMessage());
+            return "{\"documents\" : -1, \"error\" : \"IO error\" }";
+        }
+    }
+
+    public String getMatchId(String type, String docid, String tofrom) {
+        return new StringBuilder().append("contains-").append(type).append("!")
+                .append(type).append("_").append(docid).append("-")
+                .append(tofrom).toString();
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/web/TRACE.java b/src/main/java/de/ids_mannheim/korap/web/TRACE.java
new file mode 100644
index 0000000..e33089d
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/web/TRACE.java
@@ -0,0 +1,17 @@
+package de.ids_mannheim.korap.web;
+
+import javax.ws.rs.HttpMethod;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author hanl
+ * @date 03/07/2014
+ */
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@HttpMethod("TRACE")
+public @interface TRACE {
+}
diff --git a/src/main/java/de/ids_mannheim/korap/web/service/LightService.java b/src/main/java/de/ids_mannheim/korap/web/service/LightService.java
new file mode 100644
index 0000000..bd1be22
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/web/service/LightService.java
@@ -0,0 +1,346 @@
+package de.ids_mannheim.korap.web.service;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.sun.jersey.core.util.MultivaluedMapImpl;
+import de.ids_mannheim.korap.config.BeanConfiguration;
+import de.ids_mannheim.korap.config.KustvaktConfiguration;
+import de.ids_mannheim.korap.exceptions.KorAPException;
+import de.ids_mannheim.korap.exceptions.StatusCodes;
+import de.ids_mannheim.korap.graphdb.collo.ColloQuery;
+import de.ids_mannheim.korap.graphdb.collo.Dependency;
+import de.ids_mannheim.korap.query.serialize.IdWriter;
+import de.ids_mannheim.korap.query.serialize.MetaQueryBuilder;
+import de.ids_mannheim.korap.query.serialize.QuerySerializer;
+import de.ids_mannheim.korap.utils.CollectionQueryBuilder;
+import de.ids_mannheim.korap.utils.JsonUtils;
+import de.ids_mannheim.korap.utils.KorAPLogger;
+import de.ids_mannheim.korap.utils.StringUtils;
+import de.ids_mannheim.korap.web.ClientsHandler;
+import de.ids_mannheim.korap.web.SearchLucene;
+import de.ids_mannheim.korap.web.TRACE;
+import de.ids_mannheim.korap.web.utils.KustvaktResponseHandler;
+import org.slf4j.Logger;
+
+import javax.ws.rs.*;
+import javax.ws.rs.core.*;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author hanl
+ * @date 29/01/2014
+ */
+@Path("v0.1" + "/")
+@Produces(MediaType.APPLICATION_JSON + ";charset=utf-8")
+public class LightService {
+
+    private static Logger jlog = KorAPLogger.initiate(LightService.class);
+
+    private SearchLucene searchLucene;
+    private ClientsHandler graphDBhandler;
+
+    public LightService() {
+        this.searchLucene = new SearchLucene(
+                BeanConfiguration.getConfiguration().getIndexDir());
+        UriBuilder builder = UriBuilder.fromUri("http://10.0.10.13").port(9997);
+        this.graphDBhandler = new ClientsHandler(builder.build());
+    }
+
+    /**
+     * @param properties
+     * @param sfs
+     * @param limit
+     * @param query
+     * @param ql
+     * @param context
+     * @param foundry
+     * @param wPaths
+     * @return
+     */
+    //todo: add entry point where a json collection can be injected as well
+    @GET
+    @Path("colloc")
+    public Response getCollocationsAll(@QueryParam("props") String properties,
+            @QueryParam("sfskip") Integer sfs,
+            @QueryParam("sflimit") Integer limit, @QueryParam("q") String query,
+            @QueryParam("ql") String ql, @QueryParam("context") Integer context,
+            @QueryParam("foundry") String foundry,
+            @QueryParam("paths") Boolean wPaths) {
+        ColloQuery.ColloQueryBuilder builder;
+        String result;
+        try {
+            builder = new ColloQuery.ColloQueryBuilder();
+            QuerySerializer s = new QuerySerializer().setQuery(query, ql);
+            //todo: fix collectionbuilder
+            //        s.setDeprCollection(builder);
+            IdWriter writer = new IdWriter(s.toJSON()).process();
+            List collprops = JsonUtils.convertToList(properties);
+
+            if (context != null)
+                builder.context(context).collocateProps(collprops);
+            if (limit != null)
+                builder.surfaceLimit(limit);
+            if (sfs != null)
+                builder.surfaceSkip(sfs);
+            if (foundry != null)
+                builder.foundry(foundry);
+            builder.nodeQueryJS(writer.toJSON())
+                    .dep(new ArrayList<Dependency>()).withPaths(wPaths);
+
+            result = graphDBhandler
+                    .getResponse("distCollo", "q", builder.build().toJSON());
+        }catch (KorAPException e) {
+            throw KustvaktResponseHandler.throwit(e);
+        }catch (JsonProcessingException e) {
+            throw KustvaktResponseHandler.throwit(StatusCodes.ILLEGAL_ARGUMENT);
+        }
+        return Response.ok(result).build();
+    }
+
+    @POST
+    @Path("colloc")
+    public Response getCollocatioBase(@QueryParam("q") String query) {
+        String result;
+        try {
+            result = graphDBhandler.getResponse("distCollo", "q", query);
+        }catch (KorAPException e) {
+            throw KustvaktResponseHandler.throwit(e);
+        }
+        return Response.ok(result).build();
+    }
+
+    public Response postMatchFavorite() {
+        return Response.ok().build();
+    }
+
+    @TRACE
+    @Path("search")
+    public Response buildQuery(@QueryParam("q") String q,
+            @QueryParam("ql") String ql, @QueryParam("v") String v,
+            @QueryParam("context") String context,
+            @QueryParam("cutoff") Boolean cutoff,
+            @QueryParam("count") Integer pageLength,
+            @QueryParam("offset") Integer pageIndex,
+            @QueryParam("page") Integer startPage,
+            @QueryParam("ref") String reference, @QueryParam("cq") String cq) {
+        QuerySerializer ss = new QuerySerializer().setQuery(q, ql, v);
+
+        MetaQueryBuilder meta = new MetaQueryBuilder();
+        if (pageIndex != null)
+            meta.addEntry("startIndex", pageIndex);
+        if (pageIndex == null && startPage != null)
+            meta.addEntry("startPage", startPage);
+        if (pageLength != null)
+            meta.addEntry("count", pageLength);
+        if (context != null)
+            meta.setSpanContext(context);
+        meta.addEntry("cutOff", cutoff);
+        ss.addMeta(meta);
+        //todo: test this
+        ss.setCollection(cq);
+        return Response.ok(ss.toJSON()).build();
+    }
+
+    @POST
+    @Path("search")
+    public Response queryRaw(@QueryParam("engine") String engine,
+            String jsonld) {
+        KustvaktConfiguration.BACKENDS eng = BeanConfiguration
+                .getConfiguration().chooseBackend(engine);
+
+        // todo: should be possible to add the meta part to the query serialization
+        jlog.info("Serialized search: {}", jsonld);
+
+        // todo: Security Parsing and rewrite
+        // fixme: to use the systemarchitecture pointcut thingis, searchlucene must be injected via
+        String result = searchLucene.search(jsonld);
+        KorAPLogger.QUERY_LOGGER.trace("The result set: {}", result);
+        return Response.ok(result).build();
+    }
+
+    @GET
+    @Path("search")
+    public Response searchbyNameAll(@Context SecurityContext securityContext,
+            @QueryParam("q") String q, @QueryParam("ql") String ql,
+            @QueryParam("v") String v, @QueryParam("context") String ctx,
+            @QueryParam("cutoff") Boolean cutoff,
+            @QueryParam("count") Integer pageLength,
+            @QueryParam("offset") Integer pageIndex,
+            @QueryParam("page") Integer pageInteger,
+            @QueryParam("cq") String cq, @QueryParam("engine") String engine) {
+        KustvaktConfiguration.BACKENDS eng = BeanConfiguration
+                .getConfiguration().chooseBackend(engine);
+
+        String result;
+        QuerySerializer serializer = new QuerySerializer().setQuery(q, ql, v);
+        MetaQueryBuilder meta = new MetaQueryBuilder();
+        meta.fillMeta(pageIndex, pageInteger, pageLength, ctx, cutoff);
+        // fixme: should only apply to CQL queries per default!
+        //        meta.addEntry("itemsPerResource", 1);
+        serializer.addMeta(meta);
+
+        // policy rewrite!
+        String query = serializer.toJSON();
+        jlog.info("the serialized query {}", query);
+
+        if (eng.equals(KustvaktConfiguration.BACKENDS.NEO4J)) {
+            MultivaluedMap map = new MultivaluedMapImpl();
+            map.add("q", query);
+            map.add("count", String.valueOf(pageLength));
+            map.add("lctxs",
+                    String.valueOf(meta.getSpanContext().getLeft_size()));
+            map.add("rctxs",
+                    String.valueOf(meta.getSpanContext().getRight_size()));
+            try {
+                result = this.graphDBhandler.getResponse(map, "distKwic");
+            }catch (KorAPException e) {
+                throw KustvaktResponseHandler.throwit(e);
+            }
+        }else
+            result = searchLucene.search(query);
+        KorAPLogger.QUERY_LOGGER.trace("The result set: {}", result);
+        return Response.ok(result).build();
+    }
+
+    /**
+     * param context will be like this: context: "3-t,2-c"
+     * <p/>
+     * id does not have to be an integer. name is also possible, in which case a type reference is required
+     *
+     * @param query
+     * @param ql
+     * @param v
+     * @param ctx
+     * @param cutoff
+     * @param pageLength
+     * @param pageIndex
+     * @param pageInteger
+     * @param id
+     * @param type
+     * @param cq
+     * @param raw
+     * @param engine
+     * @return
+     */
+    //fixme: does not use policyrewrite!
+    @GET
+    @Path("/{type}/{id}/search")
+    public Response searchbyName(@QueryParam("q") String query,
+            @QueryParam("ql") String ql, @QueryParam("v") String v,
+            @QueryParam("context") String ctx,
+            @QueryParam("cutoff") Boolean cutoff,
+            @QueryParam("count") Integer pageLength,
+            @QueryParam("offset") Integer pageIndex,
+            @QueryParam("page") Integer pageInteger, @PathParam("id") String id,
+            @PathParam("type") String type, @QueryParam("cq") String cq,
+            @QueryParam("raw") Boolean raw,
+            @QueryParam("engine") String engine) {
+        // ref is a virtual collection id!
+        KustvaktConfiguration.BACKENDS eng = BeanConfiguration
+                .getConfiguration().chooseBackend(engine);
+        raw = raw == null ? false : raw;
+        MetaQueryBuilder meta = new MetaQueryBuilder();
+        if (!raw) {
+            QuerySerializer s = new QuerySerializer().setQuery(query, ql, v);
+            meta.fillMeta(pageIndex, pageInteger, pageLength, ctx, cutoff);
+            // should only apply to CQL queries
+            //                meta.addEntry("itemsPerResource", 1);
+            s.addMeta(meta);
+            query = s.toJSON();
+        }
+        String result;
+        try {
+            if (eng.equals(KustvaktConfiguration.BACKENDS.NEO4J)) {
+                if (raw)
+                    throw KustvaktResponseHandler
+                            .throwit(StatusCodes.ILLEGAL_ARGUMENT,
+                                    "raw not supported!", null);
+                MultivaluedMap map = new MultivaluedMapImpl();
+                map.add("q", query);
+                map.add("count", String.valueOf(pageLength));
+                map.add("lctxs",
+                        String.valueOf(meta.getSpanContext().getLeft_size()));
+                map.add("rctxs",
+                        String.valueOf(meta.getSpanContext().getRight_size()));
+                result = this.graphDBhandler.getResponse(map, "distKwic");
+            }else
+                result = searchLucene.search(query);
+
+        }catch (Exception e) {
+            KorAPLogger.ERROR_LOGGER
+                    .error("Exception for serialized query: " + query, e);
+            throw KustvaktResponseHandler.throwit(500, e.getMessage(), null);
+        }
+
+        KorAPLogger.QUERY_LOGGER.trace("The result set: {}", result);
+        return Response.ok(result).build();
+    }
+
+    //todo: switch to new serialization
+    @POST
+    @Path("stats")
+    public Response getStats(String json) {
+        CollectionQueryBuilder builder = new CollectionQueryBuilder();
+        builder.addResource(json);
+
+        String stats = searchLucene.getStatistics(builder.toCollections());
+        if (stats.contains("-1"))
+            throw KustvaktResponseHandler.throwit(StatusCodes.EMPTY_RESULTS);
+
+        return Response.ok(stats).build();
+    }
+
+    //fixme: only allowed for corpus?!
+    @GET
+    @Path("/corpus/{id}/{docid}/{rest}/matchInfo")
+    public Response getMatchInfo(@PathParam("id") String id,
+            @PathParam("docid") String docid, @PathParam("rest") String rest,
+            @QueryParam("foundry") Set<String> foundries,
+            @QueryParam("layer") Set<String> layers,
+            @QueryParam("spans") Boolean spans) {
+        spans = spans != null ? spans : false;
+        String matchid = searchLucene.getMatchId(id, docid, rest);
+
+        if (layers == null || layers.isEmpty())
+            layers = new HashSet<>();
+
+        boolean match_only = foundries == null || foundries.isEmpty();
+
+        String results;
+        // fixme: checks for policy matching
+        // fixme: currently disabled, due to mishab in foundry/layer spec
+        // fixme:
+        if (foundries != null && foundries.size() > 1000) {
+            Set<String> f_list = new HashSet<>();
+            Set<String> l_list = new HashSet<>();
+
+            for (String spl : new ArrayList<>(foundries)) {
+
+                String[] sep = StringUtils.splitAnnotations(spl);
+                if (spl != null) {
+                    f_list.add(sep[0]);
+                    l_list.add(sep[1]);
+                }
+                results = searchLucene
+                        .getMatch(matchid, new ArrayList<>(f_list),
+                                new ArrayList<>(l_list), spans, false, true);
+
+            }
+        }
+        try {
+            if (!match_only)
+                results = searchLucene
+                        .getMatch(matchid, new ArrayList<>(foundries),
+                                new ArrayList<>(layers), spans, false, true);
+            else
+                results = searchLucene.getMatch(matchid);
+        }catch (Exception e) {
+            KorAPLogger.ERROR_LOGGER.error("Exception encountered!", e);
+            throw KustvaktResponseHandler
+                    .throwit(StatusCodes.ILLEGAL_ARGUMENT, e.getMessage(), "");
+        }
+        return Response.ok(results).build();
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/web/utils/FormWrapper.java b/src/main/java/de/ids_mannheim/korap/web/utils/FormWrapper.java
new file mode 100644
index 0000000..b1dad85
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/web/utils/FormWrapper.java
@@ -0,0 +1,35 @@
+package de.ids_mannheim.korap.web.utils;
+
+import javax.ws.rs.core.MultivaluedMap;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author hanl
+ * @date 18/05/2015
+ * Helper class to wrapp multivaluedmap into a hashmap. Depending on the strict parameter,
+ * list values are retained in the resulting wrapper map.
+ */
+public class FormWrapper extends HashMap<String, Object> {
+
+    public FormWrapper(MultivaluedMap form, boolean strict) {
+        super(toMap(form, strict));
+    }
+
+    public FormWrapper(MultivaluedMap form) {
+        super(toMap(form, true));
+    }
+
+    private static HashMap<String, Object> toMap(MultivaluedMap<String, Object> form,
+            boolean strict) {
+        HashMap<String, Object> map = new HashMap<>();
+        for (Map.Entry<String, List<Object>> e : form.entrySet()) {
+            if (e.getValue().size() == 1)
+                map.put(e.getKey(), e.getValue().get(0));
+            else if (!strict)
+                map.put(e.getKey(), e.getValue());
+        }
+        return map;
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/web/utils/HTMLBuilder.java b/src/main/java/de/ids_mannheim/korap/web/utils/HTMLBuilder.java
new file mode 100644
index 0000000..f6da418
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/web/utils/HTMLBuilder.java
@@ -0,0 +1,56 @@
+package de.ids_mannheim.korap.web.utils;
+
+/**
+ * @author hanl
+ * @date 12/04/2014
+ */
+public class HTMLBuilder {
+
+    private StringBuilder html;
+    private StringBuilder body;
+    private String bodyAttr;
+
+    public HTMLBuilder() {
+        html = new StringBuilder();
+        body = new StringBuilder();
+        bodyAttr = "";
+        html.append("<html>");
+    }
+
+
+    public void addHeader(String header, int h) {
+        html.append("<h" + h + ">");
+        html.append(header);
+        html.append("</h" + h + ">");
+    }
+
+    public void addToBody(String body) {
+        this.body.append(body);
+    }
+
+    public void addToBody(String body, String attributes) {
+        this.body.append(body);
+        bodyAttr = attributes;
+    }
+
+    public String build() {
+        if (bodyAttr.isEmpty())
+            html.append("<body>");
+        else {
+            html.append("<body ");
+            html.append(bodyAttr);
+            html.append(">");
+        }
+
+        html.append(body);
+        html.append("</body>");
+        html.append("</html>");
+        return html.toString();
+    }
+
+
+    @Override
+    public String toString() {
+        return build();
+    }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/web/utils/KustvaktResponseHandler.java b/src/main/java/de/ids_mannheim/korap/web/utils/KustvaktResponseHandler.java
new file mode 100644
index 0000000..f99a520
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/web/utils/KustvaktResponseHandler.java
@@ -0,0 +1,77 @@
+package de.ids_mannheim.korap.web.utils;
+
+import de.ids_mannheim.korap.auditing.AuditRecord;
+import de.ids_mannheim.korap.config.BeanConfiguration;
+import de.ids_mannheim.korap.exceptions.BaseException;
+import de.ids_mannheim.korap.exceptions.KorAPException;
+import de.ids_mannheim.korap.exceptions.StatusCodes;
+import de.ids_mannheim.korap.interfaces.AuditingIface;
+import de.ids_mannheim.korap.response.Notifications;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Response;
+import java.util.List;
+
+/**
+ * @author hanl
+ * @date 29/01/2014
+ */
+public class KustvaktResponseHandler {
+
+    private static AuditingIface auditing = BeanConfiguration
+            .getAuditingProvider();
+
+    private static void register(List<AuditRecord> records) {
+        if (auditing != null && !records.isEmpty())
+            auditing.audit(records);
+    }
+
+    public static WebApplicationException throwit(BaseException e) {
+        //fixme: ??!
+        e.printStackTrace();
+        return new WebApplicationException(
+                Response.status(Response.Status.BAD_REQUEST)
+                        .entity(buildNotification(e)).build());
+    }
+
+    @Deprecated
+    public static WebApplicationException throwit(int code) {
+        KorAPException e = new KorAPException(code);
+        return new WebApplicationException(
+                Response.status(Response.Status.OK).entity(buildNotification(e))
+                        .build());
+    }
+
+    @Deprecated
+    public static WebApplicationException throwit(int code, String message,
+            String entity) {
+        KorAPException e = new KorAPException(code, message, entity);
+        return new WebApplicationException(
+                Response.status(Response.Status.OK).entity(buildNotification(e))
+                        .build());
+    }
+
+    private static String buildNotification(BaseException e) {
+        KustvaktResponseHandler.register(e.getRecords());
+        return buildNotification(e.getStatusCode(), e.getMessage(),
+                e.getEntity());
+    }
+
+    private static String buildNotification(int code, String message,
+            String entity) {
+        Notifications notif = new Notifications();
+        notif.addError(code, message, entity);
+        return notif.toJsonString() + "\n";
+    }
+
+    public static WebApplicationException throwAuthenticationException() {
+        KorAPException e = new KorAPException(StatusCodes.BAD_CREDENTIALS);
+        return new WebApplicationException(
+                Response.status(Response.Status.UNAUTHORIZED)
+                        .header(HttpHeaders.WWW_AUTHENTICATE,
+                                "Basic realm=Kustvakt Authentication Service")
+                        .entity(buildNotification(e)).build());
+    }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/web/utils/LocaleProvider.java b/src/main/java/de/ids_mannheim/korap/web/utils/LocaleProvider.java
new file mode 100644
index 0000000..47e8e03
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/web/utils/LocaleProvider.java
@@ -0,0 +1,45 @@
+package de.ids_mannheim.korap.web.utils;
+
+import com.sun.jersey.api.core.HttpContext;
+import com.sun.jersey.core.spi.component.ComponentContext;
+import com.sun.jersey.core.spi.component.ComponentScope;
+import com.sun.jersey.server.impl.inject.AbstractHttpContextInjectable;
+import com.sun.jersey.spi.inject.Injectable;
+import com.sun.jersey.spi.inject.InjectableProvider;
+
+import javax.ws.rs.core.Context;
+import javax.ws.rs.ext.Provider;
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * @author hanl
+ * @date 04/02/2014
+ */
+@Provider
+public class LocaleProvider
+        extends AbstractHttpContextInjectable<Locale>
+        implements InjectableProvider<Context, Type> {
+
+    @Override
+    public Locale getValue(HttpContext httpContext) {
+        final List<Locale> locales = httpContext.getRequest().getAcceptableLanguages();
+        if (locales.isEmpty())
+            return Locale.US;
+        return locales.get(0);
+    }
+
+    @Override
+    public ComponentScope getScope() {
+        return ComponentScope.PerRequest;
+    }
+
+    @Override
+    public Injectable getInjectable(ComponentContext ic, Context context, Type type) {
+        if (type.equals(Locale.class))
+            return this;
+        return null;
+    }
+}
+
diff --git a/src/main/resources/.DS_Store b/src/main/resources/.DS_Store
new file mode 100644
index 0000000..5008ddf
--- /dev/null
+++ b/src/main/resources/.DS_Store
Binary files differ
diff --git a/src/main/resources/changelog b/src/main/resources/changelog
new file mode 100644
index 0000000..50f47a7
--- /dev/null
+++ b/src/main/resources/changelog
@@ -0,0 +1,6 @@
+=== CHANGELOG FILE ===
+
+05/05/2015
+    - ADD: rest test suite for user service
+    - MOD: setup parameter modification
+    - ADD: oauth2 client unique constraint
diff --git a/src/main/resources/default-config.xml b/src/main/resources/default-config.xml
new file mode 100644
index 0000000..7e3c557
--- /dev/null
+++ b/src/main/resources/default-config.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:util="http://www.springframework.org/schema/util"
+       xmlns="http://www.springframework.org/schema/beans"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans
+                            http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
+                            http://www.springframework.org/schema/util
+                            http://www.springframework.org/schema/util/spring-util-4.0.xsd">
+
+
+    <!--<context:property-placeholder location="classpath:kustvakt.conf"/>-->
+
+    <util:properties id="props" location="classpath:kustvakt.conf"/>
+
+    <bean id="auditingProvider"
+          class="de.ids_mannheim.korap.interfaces.defaults.DefaultAuditing">
+    </bean>
+
+    <bean id="config"
+          class="de.ids_mannheim.korap.config.KustvaktConfiguration">
+        <property name="properties" ref="props"/>
+    </bean>
+
+    <bean name="encryption"
+          class="de.ids_mannheim.korap.interfaces.defaults.DefaultEncryption">
+    </bean>
+</beans>
\ No newline at end of file