Context.java

package org.aplikator.server.data;


import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Locale;
import java.util.Scanner;
import java.util.UUID;

import org.aplikator.client.shared.data.Operation;
import org.aplikator.client.shared.data.PrimaryKey;
import org.aplikator.server.DescriptorRegistry;
import org.aplikator.server.descriptor.Collection;
import org.aplikator.server.descriptor.Entity;
import org.aplikator.server.descriptor.View;
import org.aplikator.server.persistence.Transaction;

public class Context {

    private final HttpServletRequest httpServletRequest;
    private final HttpServletResponse httpServletResponse;
    private final AplikatorServiceBackend aplikatorServiceBackend;
    private RecordContainer recordContainer;
    private Transaction transaction;


    public Context(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AplikatorServiceBackend aplikatorServiceBackend, RecordContainer rc) {
        super();
        this.httpServletRequest = httpServletRequest;
        this.httpServletResponse = httpServletResponse;
        this.aplikatorServiceBackend = aplikatorServiceBackend;
        transaction = aplikatorServiceBackend.persister.beginTransaction();
        this.recordContainer = rc;
        //System.out.println("CONTEXT:"+httpServletRequest + " LENGTH:"+httpServletRequest.getContentLength());
        //System.out.println("BODY:"+extractPostRequestBody(httpServletRequest));
    }

    static String extractPostRequestBody(HttpServletRequest request) {
        if ("POST".equalsIgnoreCase(request.getMethod())) {
            Scanner s = null;
            try {
                s = new Scanner(request.getInputStream(), "UTF-8").useDelimiter("\\A");
            } catch (IOException e) {
                e.printStackTrace();
            }
            return s.hasNext() ? s.next() : "";
        }
        return "";
    }


    public HttpServletRequest getHttpServletRequest() {
        return this.httpServletRequest;
    }

    public HttpServletResponse getHttpServletResponse() {
        return this.httpServletResponse;
    }

    public Locale getUserLocale() {
        return this.httpServletRequest.getLocale();
    }

    AplikatorServiceBackend getAplikatorServiceBackend() {
        return aplikatorServiceBackend;
    }

    public RecordContainer getRecordContainer() {
        if (recordContainer == null) {
            recordContainer = new RecordContainer();
        }
        return recordContainer;
    }

    public void clearRecordContainer() {
        getRecordContainer().clear();
    }

    public void addNewRecordToContainer(Record record) {
        View view = ((Entity) DescriptorRegistry.get().getDescriptionItem(record.getPrimaryKey().getEntityId())).view();
        getRecordContainer().addRecord(view, null, record, Operation.CREATE);
    }

    public void addUpdatedRecordToContainer(Record originalRecord, Record updatedRecord) {
        View view = ((Entity) DescriptorRegistry.get().getDescriptionItem(originalRecord.getPrimaryKey().getEntityId())).view();
        getRecordContainer().addRecord(view, originalRecord, updatedRecord, Operation.UPDATE);
    }

    public void addDeletedRecordToContainer(Record record) {
        Entity entity = (Entity) DescriptorRegistry.get().getDescriptionItem(record.getPrimaryKey().getEntityId());
       /* for (Property<? extends Serializable> property : entity.getProperties()) {
            if (property instanceof Collection){
                List<Record> nestedRecords = record.getCollectionRecords((Collection) property, this);
                for (Record nestedRecord : nestedRecords) {
                    this.addDeletedRecordToContainer(nestedRecord);
                }
            }
        }*/
        View view = entity.view();
        getRecordContainer().addRecord(view, record, null, Operation.DELETE);
    }

    public void prepareDuplicateCollection(ContainerNode node, Collection collection, View collectionView) {
        for (Record record : node.getOriginal().getCollectionRecords(collection, collectionView, this)) {
            Record duplicatedRecord = record.clone();
            duplicatedRecord.setPrimaryKey(new PrimaryKey(record.getPrimaryKey().getEntityId(), UUID.randomUUID().toString()));
            duplicatedRecord.setOwnerPrimaryKey(node.getEdited().getPrimaryKey());
            duplicatedRecord.setOwnerProperty(collection);
            this.getRecordContainer().addRecord(node.getView(), null, duplicatedRecord, Operation.PREPARE);
        }
    }

    public void processRecordContainer() {
        recordContainer = getAplikatorServiceBackend().processRecords(getRecordContainer(), this);
    }

    public RecordContainer processRecordContainer(RecordContainer rc) {
        return getAplikatorServiceBackend().processRecords(rc, this);
    }

    public QueryBuilder getRecords(View view) {
        return new QueryBuilder(this, view);
    }

    public QueryBuilder getRecords(Entity entity) {
        return new QueryBuilder(this, entity.view());
    }

    public Record getRecord(PrimaryKey primaryKey, View view) {
        return getAplikatorServiceBackend().getRecord(primaryKey, view, this);
    }


    public Transaction getTransaction() {
        return transaction;
    }

    public void closeTransaction() {
        aplikatorServiceBackend.persister.close(transaction);
    }

    public boolean isUserInRole(String role) {
        //System.out.println("USER:" + getHttpServletRequest().getRemoteUser() + " ROLE:" + role + "-" + getHttpServletRequest().isUserInRole(role) + "(" + getHttpServletRequest() + ")");
        //System.out.println("USERPRINCIPALCLASS:" +getHttpServletRequest().getUserPrincipal().getClass());
        return getHttpServletRequest().isUserInRole(role);
    }

    public boolean isAuthenticated() {
        return getHttpServletRequest().getRemoteUser() != null;
    }

}