Ignore:
Timestamp:
Jul 2, 2012, 8:39:46 PM (12 years ago)
Author:
casties
Branch:
default
Message:

store seems to work now :-)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/main/java/de/mpiwg/itgroup/annotations/restlet/AnnotatorResourceImpl.java

    r3 r4  
    1414import java.util.regex.Pattern;
    1515
     16import javax.servlet.ServletContext;
     17
    1618import net.oauth.jsontoken.Checker;
    1719import net.oauth.jsontoken.JsonToken;
     
    2628import org.json.JSONException;
    2729import org.json.JSONObject;
    28 import org.restlet.data.ClientInfo;
    2930import org.restlet.data.Form;
    3031import org.restlet.data.Status;
     
    3233import org.restlet.resource.Options;
    3334import org.restlet.resource.ServerResource;
    34 import org.restlet.security.User;
    35 
    36 import de.mpiwg.itgroup.annotationManager.Constants.NS;
    37 import de.mpiwg.itgroup.annotationManager.RDFHandling.Annotation;
     35
     36import de.mpiwg.itgroup.annotations.Annotation;
     37import de.mpiwg.itgroup.annotations.Annotation.FragmentTypes;
     38import de.mpiwg.itgroup.annotations.neo4j.AnnotationStore;
     39import de.mpiwg.itgroup.annotations.old.NS;
    3840
    3941/**
     
    4547public abstract class AnnotatorResourceImpl extends ServerResource {
    4648
    47     protected Logger logger = Logger.getRootLogger();
     49    protected static Logger logger = Logger.getLogger(AnnotatorResourceImpl.class);
     50
     51    private AnnotationStore store;
    4852
    4953    protected String getAllowedMethodsForHeader() {
    5054        return "OPTIONS,GET,POST";
     55    }
     56
     57    protected AnnotationStore getAnnotationStore() {
     58        if (store == null) {
     59            ServletContext sc = (ServletContext) getContext().getServerDispatcher().getContext().getAttributes()
     60                    .get("org.restlet.ext.servlet.ServletContext");
     61            logger.debug("Getting AnnotationStore from Context");
     62            store = (AnnotationStore) sc.getAttribute(RestServer.ANNSTORE_KEY);
     63        }
     64        return store;
    5165    }
    5266
     
    115129
    116130    /**
    117      * checks Annotator Auth plugin authentication information from headers. returns userId if successful.
     131     * checks Annotator Auth plugin authentication information from headers.
     132     * returns userId if successful.
    118133     *
    119134     * @param entity
     
    166181        JSONObject jo = new JSONObject();
    167182        try {
    168             jo.put("text", annot.text);
    169             jo.put("uri", annot.url);
     183            jo.put("text", annot.getBodyText());
     184            jo.put("uri", annot.getTargetBaseUri());
    170185
    171186            if (makeUserObject) {
     
    173188                JSONObject userObject = new JSONObject();
    174189                // save creator as uri
    175                 userObject.put("uri", annot.creator);
     190                userObject.put("uri", annot.getCreatorUri());
    176191                // make short user id
    177                 String userID = annot.creator;
    178                 if (userID.startsWith(NS.MPIWG_PERSONS_URL)) {
    179                     userID = userID.replace(NS.MPIWG_PERSONS_URL, ""); // entferne
     192                String userId = annot.getCreatorUri();
     193                if (userId != null && userId.startsWith(NS.MPIWG_PERSONS_URL)) {
     194                    userId = userId.replace(NS.MPIWG_PERSONS_URL, ""); // entferne
    180195                                                                       // NAMESPACE
    181196                }
    182197                // save as id
    183                 userObject.put("id", userID);
     198                userObject.put("id", userId);
    184199                // get full name
    185200                RestServer restServer = (RestServer) getApplication();
    186                 String userName = restServer.getUserNameFromLdap(userID);
     201                String userName = restServer.getUserNameFromLdap(userId);
    187202                userObject.put("name", userName);
    188203                // save user object
     
    190205            } else {
    191206                // save user as string
    192                 jo.put("user", annot.creator);
    193             }
    194 
    195             List<String> xpointers = new ArrayList<String>();
    196             if (annot.xpointers == null || annot.xpointers.size() == 0)
    197                 xpointers.add(annot.xpointer);
    198             else {
    199                 for (String xpointerString : annot.xpointers) {
    200                     xpointers.add(xpointerString);
    201                 }
    202             }
    203             if (!xpointers.isEmpty()) {
     207                jo.put("user", annot.getCreatorUri());
     208            }
     209
     210            if (annot.getTargetFragment() != null) {
    204211                // we only look at the first xpointer
    205                 String xt = getXpointerType(xpointers.get(0));
    206                 if (xt == "range") {
    207                     jo.put("ranges", transformToRanges(xpointers));
    208                 } else if (xt == "area") {
    209                     jo.put("areas", transformToAreas(xpointers));
     212                List<String> fragments = new ArrayList<String>();
     213                fragments.add(annot.getTargetFragment());
     214                FragmentTypes xt = annot.getFragmentType();
     215                if (xt == FragmentTypes.XPOINTER) {
     216                    jo.put("ranges", transformToRanges(fragments));
     217                } else if (xt == FragmentTypes.AREA) {
     218                    jo.put("areas", transformToAreas(fragments));
    210219                }
    211220            }
    212221            // encode Annotation URL (=id) in base64
    213             String annotUrl = annot.getAnnotationUri();
     222            String annotUrl = annot.getUri();
    214223            String annotId = encodeJsonId(annotUrl);
    215224            jo.put("id", annotId);
     
    222231    }
    223232
    224     private String getXpointerType(String xpointer) {
    225         if (xpointer.contains("#xpointer")) {
    226             return "range";
    227         } else if (xpointer.contains("#xywh")) {
    228             return "area";
    229         }
    230         return null;
    231     }
    232 
    233233    private JSONArray transformToRanges(List<String> xpointers) {
    234234
     
    236236
    237237        Pattern rg = Pattern
    238                 .compile("#xpointer\\(start-point\\(string-range\\(\"([^\"]*)\",([^,]*),1\\)\\)/range-to\\(end-point\\(string-range\\(\"([^\"]*)\",([^,]*),1\\)\\)\\)\\)");
    239         Pattern rg1 = Pattern.compile("#xpointer\\(start-point\\(string-range\\(\"([^\"]*)\",([^,]*),1\\)\\)\\)");
     238                .compile("xpointer\\(start-point\\(string-range\\(\"([^\"]*)\",([^,]*),1\\)\\)/range-to\\(end-point\\(string-range\\(\"([^\"]*)\",([^,]*),1\\)\\)\\)\\)");
     239        Pattern rg1 = Pattern.compile("xpointer\\(start-point\\(string-range\\(\"([^\"]*)\",([^,]*),1\\)\\)\\)");
    240240
    241241        try {
     
    278278        JSONArray ja = new JSONArray();
    279279
    280         Pattern rg = Pattern.compile("#xywh=(\\w*:)([\\d\\.]+),([\\d\\.]+),([\\d\\.]+),([\\d\\.]+)");
     280        Pattern rg = Pattern.compile("xywh=(\\w*:)([\\d\\.]+),([\\d\\.]+),([\\d\\.]+),([\\d\\.]+)");
    281281
    282282        try {
     
    308308    }
    309309
     310    protected String parseArea(JSONObject area) throws JSONException, UnsupportedEncodingException {
     311        String x = area.getString("x");
     312        String y = area.getString("y");
     313        String width = "0";
     314        String height = "0";
     315        if (area.has("width")) {
     316            width = area.getString("width");
     317            height = area.getString("height");
     318        }
     319        String fragment = URLEncoder.encode(String.format("xywh=fraction:%s,%s,%s,%s", x, y, width, height), "utf-8");
     320        return fragment;
     321    }
     322
     323    protected String parseRange(JSONObject range) throws JSONException, UnsupportedEncodingException {
     324        String start = range.getString("start");
     325        String end = range.getString("end");
     326        String startOffset = range.getString("startOffset");
     327        String endOffset = range.getString("endOffset");
     328
     329        String fragment = URLEncoder.encode(String.format(
     330                "xpointer(start-point(string-range(\"%s\",%s,1))/range-to(end-point(string-range(\"%s\",%s,1))))", start,
     331                startOffset, end, endOffset), "utf-8");
     332        return fragment;
     333    }
     334
    310335    /**
    311336     * creates an Annotation object with data from JSON.
    312337     *
    313      * uses the specification from the annotator project: {@link https ://github.com/okfn/annotator/wiki/Annotation-format}
    314      *
    315      * The username will be transformed to an URI if not given already as URI, if not it will set to the MPIWG namespace defined in
     338     * uses the specification from the annotator project: {@link https
     339     * ://github.com/okfn/annotator/wiki/Annotation-format}
     340     *
     341     * The username will be transformed to an URI if not given already as URI,
     342     * if not it will set to the MPIWG namespace defined in
    316343     * de.mpiwg.itgroup.annotationManager.Constants.NS
    317344     *
     
    319346     * @return
    320347     * @throws JSONException
    321      */
    322     public Annotation createAnnotation(JSONObject jo, Representation entity) throws JSONException {
     348     * @throws UnsupportedEncodingException
     349     */
     350    public Annotation createAnnotation(JSONObject jo, Representation entity) throws JSONException, UnsupportedEncodingException {
    323351        return updateAnnotation(new Annotation(), jo, entity);
    324352    }
    325353
    326     public Annotation updateAnnotation(Annotation annot, JSONObject jo, Representation entity) throws JSONException {
     354    public Annotation updateAnnotation(Annotation annot, JSONObject jo, Representation entity) throws JSONException,
     355            UnsupportedEncodingException {
    327356        // annotated uri
    328         String url = annot.url;
    329357        if (jo.has("uri")) {
    330             url = jo.getString("uri");
     358            annot.setTargetBaseUri(jo.getString("uri"));
    331359        }
    332360        // annotation text
    333         String text = annot.text;
    334361        if (jo.has("text")) {
    335             text = jo.getString("text");
     362            annot.setBodyText(jo.getString("text"));
    336363        }
    337364        // check authentication
    338365        String authUser = checkAuthToken(entity);
    339366        if (authUser == null) {
    340             // try http auth
    341             User httpUser = getHttpAuthUser(entity);
    342             if (httpUser == null) {
    343                 setStatus(Status.CLIENT_ERROR_FORBIDDEN);
    344                 return null;
    345             }
    346             authUser = httpUser.getIdentifier();
     367            /*
     368             * // try http auth User httpUser = getHttpAuthUser(entity); if
     369             * (httpUser == null) {
     370             */
     371            setStatus(Status.CLIENT_ERROR_FORBIDDEN);
     372            return null;
     373            /*
     374             * } authUser = httpUser.getIdentifier();
     375             */
    347376        }
    348377        // username not required, if no username given authuser will be used
    349378        String username = null;
    350         String userUri = annot.creator;
     379        String userUri = annot.getCreatorUri();
    351380        if (jo.has("user")) {
    352381            if (jo.get("user") instanceof String) {
     
    381410
    382411        // create xpointer from the first range/area
    383         String xpointer = annot.xpointer;
    384412        if (jo.has("ranges")) {
    385413            JSONObject ranges = jo.getJSONArray("ranges").getJSONObject(0);
    386             String start = ranges.getString("start");
    387             String end = ranges.getString("end");
    388             String startOffset = ranges.getString("startOffset");
    389             String endOffset = ranges.getString("endOffset");
    390 
    391             try {
    392                 xpointer = url
    393                         + "#"
    394                         + URLEncoder.encode(String.format(
    395                                 "xpointer(start-point(string-range(\"%s\",%s,1))/range-to(end-point(string-range(\"%s\",%s,1))))",
    396                                 start, startOffset, end, endOffset), "utf-8");
    397             } catch (UnsupportedEncodingException e) {
    398                 e.printStackTrace();
    399                 setStatus(Status.SERVER_ERROR_INTERNAL);
    400                 return null;
    401             }
     414            annot.setFragmentType(FragmentTypes.XPOINTER);
     415            String fragment = parseRange(ranges);
     416            annot.setTargetFragment(fragment);
    402417        }
    403418        if (jo.has("areas")) {
    404419            JSONObject area = jo.getJSONArray("areas").getJSONObject(0);
    405             String x = area.getString("x");
    406             String y = area.getString("y");
    407             String width = "0";
    408             String height = "0";
    409             if (area.has("width")) {
    410                 width = area.getString("width");
    411                 height = area.getString("height");
    412             }
    413             try {
    414                 xpointer = url + "#" + URLEncoder.encode(String.format("xywh=fraction:%s,%s,%s,%s", x, y, width, height), "utf-8");
    415             } catch (UnsupportedEncodingException e) {
    416                 e.printStackTrace();
    417                 setStatus(Status.SERVER_ERROR_INTERNAL);
    418                 return null;
    419             }
    420         }
    421         return new Annotation(xpointer, userUri, annot.time, text, annot.type);
    422     }
    423 
    424     /**
    425      * returns the logged in User.
    426      *
    427      * @param entity
    428      * @return
    429      */
    430     protected User getHttpAuthUser(Representation entity) {
    431         RestServer restServer = (RestServer) getApplication();
    432         if (!restServer.authenticate(getRequest(), getResponse())) {
    433             // Not authenticated
    434             return null;
    435         }
    436 
    437         ClientInfo ci = getRequest().getClientInfo();
    438         logger.debug(ci);
    439         return getRequest().getClientInfo().getUser();
    440 
     420            annot.setFragmentType(FragmentTypes.AREA);
     421            String fragment = parseArea(area);
     422            annot.setTargetFragment(fragment);
     423        }
     424        return annot;
    441425    }
    442426
Note: See TracChangeset for help on using the changeset viewer.