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/AnnotatorAnnotations.java

    r3 r4  
    66
    77import java.io.IOException;
    8 import java.util.ArrayList;
    9 import java.util.List;
    108
    119import org.json.JSONArray;
    1210import org.json.JSONException;
    1311import org.json.JSONObject;
    14 import org.restlet.Context;
    15 import org.restlet.data.Form;
    16 import org.restlet.data.MediaType;
    17 import org.restlet.data.Reference;
    1812import org.restlet.data.Status;
    1913import org.restlet.ext.json.JsonRepresentation;
    2014import org.restlet.representation.Representation;
    21 import org.restlet.representation.StringRepresentation;
    2215import org.restlet.resource.Delete;
    2316import org.restlet.resource.Get;
    2417import org.restlet.resource.Post;
    2518import org.restlet.resource.Put;
    26 import org.restlet.security.User;
    27 
    28 import de.mpiwg.itgroup.annotationManager.Constants.NS;
    29 import de.mpiwg.itgroup.annotationManager.Errors.TripleStoreSearchError;
    30 import de.mpiwg.itgroup.annotationManager.Errors.TripleStoreStoreError;
    31 import de.mpiwg.itgroup.annotationManager.RDFHandling.Annotation;
    32 import de.mpiwg.itgroup.annotationManager.RDFHandling.Convert;
    33 import de.mpiwg.itgroup.annotationManager.RDFHandling.RDFSearcher;
    34 import de.mpiwg.itgroup.annotationManager.drupal.AnnotationHandler;
    35 import de.mpiwg.itgroup.annotationManager.drupal.UnknowUserException;
    36 import de.mpiwg.itgroup.triplestoremanager.exceptions.TripleStoreHandlerException;
     19
     20import de.mpiwg.itgroup.annotations.Annotation;
     21import de.mpiwg.itgroup.annotations.neo4j.AnnotationStore;
    3722
    3823/**
    39  * Implements the "annotations" uri of the Annotator API. see <https://github.com/okfn/annotator/wiki/Storage>
     24 * Implements the "annotations" uri of the Annotator API. see
     25 * <https://github.com/okfn/annotator/wiki/Storage>
    4026 *
    4127 * @author dwinter, casties
    … …  
    6955        logger.debug("request authenticated=" + authenticated);
    7056
    71         RDFSearcher searcher = new RDFSearcher(NS.MPIWG_ANNOT_CTX); // TODO should ge into config file
    72 
    73         try {
    74             List<Annotation> annots = searcher.searchById(id);
    75             if (annots.size() == 1) {
    76                 // there should be only one
    77                 JSONObject result = createAnnotatorJson(annots.get(0));
    78                 logger.debug("sending:");
    79                 logger.debug(result);
    80                 return new JsonRepresentation(result);
    81             } else {
    82                 JSONArray results;
    83                 results = new JSONArray();
    84                 for (Annotation annot : annots) {
    85                     JSONObject jo = createAnnotatorJson(annot);
    86                     if (jo != null) {
    87                         results.put(createAnnotatorJson(annot));
    88                     } else {
    89                         setStatus(Status.SERVER_ERROR_INTERNAL, "JSon Error");
    90                         return null;
    91                     }
    92                 }
    93                 // annotator read request returns a list of annotation objects
    94                 logger.debug("sending:");
    95                 logger.debug(results);
    96                 return new JsonRepresentation(results);
    97             }
    98         } catch (TripleStoreHandlerException e) {
    99             e.printStackTrace();
    100             setStatus(Status.SERVER_ERROR_INTERNAL, "TripleStoreHandler Error");
    101             return null;
    102         } catch (TripleStoreSearchError e) {
    103             e.printStackTrace();
    104             setStatus(Status.SERVER_ERROR_INTERNAL, "TripleStoreSearch Error");
    105             return null;
     57        Annotation annots = getAnnotationStore().getAnnotationById(id);
     58        if (annots != null) {
     59            // there should be only one
     60            JSONObject result = createAnnotatorJson(annots);
     61            logger.debug("sending:");
     62            logger.debug(result);
     63            return new JsonRepresentation(result);
     64        } else {
     65            JSONArray results = new JSONArray();
     66            // annotator read request returns a list of annotation objects
     67            logger.debug("sending:");
     68            logger.debug(results);
     69            return new JsonRepresentation(results);
    10670        }
    10771    }
    … …  
    11074     * POST with JSON content-type.
    11175     *
    112      * json hash: username: name des users xpointer: xpointer auf den Ausschnitt (incl. der URL des Dokumentes) text: text der
    113      * annotation annoturl: url auf eine Annotation falls extern
     76     * json hash: username: name des users xpointer: xpointer auf den Ausschnitt
     77     * (incl. der URL des Dokumentes) text: text der annotation annoturl: url
     78     * auf eine Annotation falls extern
    11479     *
    11580     * @return
    … …  
    139104            return null;
    140105        }
    141         if (annot == null || annot.xpointer == null || annot.creator == null) {
     106        if (annot == null) {
    142107            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
    143108            return null;
    144109        }
    145110        Annotation storedAnnot;
    146         try {
    147             // store Annotation
    148             storedAnnot = new Convert(NS.MPIWG_ANNOT_CTX).storeAnnotation(annot);
    149         } catch (TripleStoreStoreError e) {
    150             e.printStackTrace();
    151             setStatus(Status.SERVER_ERROR_INTERNAL, "TripleStore Error");
    152             return null;
    153         }
    154         /* according to https://github.com/okfn/annotator/wiki/Storage
    155          * we should return 303: see other.
    156          * For now we return the annotation.
     111        // store Annotation
     112        storedAnnot = getAnnotationStore().storeAnnotation(annot);
     113        /*
     114         * according to https://github.com/okfn/annotator/wiki/Storage we should
     115         * return 303: see other. For now we return the annotation.
    157116         */
    158117        JSONObject jo = createAnnotatorJson(storedAnnot);
    … …  
    160119        return retRep;
    161120    }
    162 
    163     /**
    164      * POST with HTML content-type.
    165      *
    166      * @param entity
    167      * @return
    168      */
    169     @Post("html")
    170     public Representation doPostHtml(Representation entity) {
    171         logger.debug("AnnotatorAnnotations doPostHtml!");
    172         Annotation annot;
    173         annot = handleForm(entity);
    174         if (annot.xpointer == null || annot.creator == null) {
    175             setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
    176 
    177             return null;
    178         }
    179 
    180         Annotation retValAnnot;
    181         try {
    182             retValAnnot = new Convert(NS.MPIWG_ANNOT_CTX).storeAnnotation(annot);
    183         } catch (TripleStoreStoreError e) {
    184             e.printStackTrace();
    185             setStatus(Status.SERVER_ERROR_INTERNAL, "TripleStore Error");
    186             return null;
    187         }
    188         if (retValAnnot == null) {
    189             return null;
    190         }
    191         String retVal = retValAnnot.getAnnotationUri();
    192         if (retVal == null) {
    193             return null;
    194         }
    195 
    196         String text = String.format("<html><body><a href=\"%s\">%s</a></body></html>", retVal.replace(">", "").replace("<", ""),
    197                 retVal.replace(">", "&gt;").replace("<", "&lt;"));
    198         Representation retRep = new StringRepresentation(text, MediaType.TEXT_HTML);
    199         return retRep;
    200     }
    201 
    202     /**
    203      *
    204      * @param entity
    205      *            should contain a form with the parameters "username", "password", "xpointer","text","uri","type"
    206      *
    207      *            username,password is optional, if not given BasicAuthentification is used.
    208      *
    209      *            If username given as a URI, the username will be transformed to an URI, username will be added to the MPIWG
    210      *            namespace defined in de.mpiwg.itgroup.annotationManager.Constants.NS
    211      *
    212      * @return
    213      */
    214     protected Annotation handleForm(Representation entity) {
    215         Annotation annot;
    216         Form form = new Form(entity);
    217         String username = form.getValues("username");
    218         String mode = form.getValues("mode");
    219         String password = form.getValues("password");
    220         String xpointer = form.getValues("xpointer");
    221         String text = form.getValues("text");
    222         String title = form.getValues("title");
    223         String url = form.getValues("url");
    224         String type = form.getValues("type");
    225         RestServer restServer = (RestServer) getApplication();
    226 
    227         // falls user and password nicht null sind:
    228         User userFromForm = null;
    229         if (username != null && password != null) {
    230             if (restServer.authenticate(username, password, getRequest())) {
    231                 userFromForm = new User(username);
    232             }
    233         }
    234         User authUser = null;
    235 
    236         if (userFromForm == null) {
    237             authUser = getHttpAuthUser(entity);
    238         }
    239 
    240         // weder BasicAuth noch FormAuth
    241         if (authUser == null && userFromForm == null) {
    242             setStatus(Status.CLIENT_ERROR_FORBIDDEN);
    243             return null;
    244         }
    245 
    246         if (userFromForm != null) {
    247             username = userFromForm.getIdentifier();
    248         } else {
    249             username = authUser.getIdentifier();
    250         }
    251 
    252         // username should be a URI, if not it will set to the MPIWG namespace defined in
    253         // de.mpiwg.itgroup.annotationManager.Constants.NS
    254         String usernameOrig = username;
    255         if (!username.startsWith("http"))
    256             username = NS.MPIWG_PERSONS_URL + username;
    257 
    258         if (mode.equals("complexAnnotation")) {// Annotation mit text in externer ressource
    259 
    260             Context context = getContext();
    261             String drupalPath = context.getParameters().getFirstValue("de.mpiwg.itgroup.annotationManager.drupalServer");
    262 
    263             AnnotationHandler ah = new AnnotationHandler(drupalPath);
    264             JSONObject newAnnot;
    265             try {
    266                 newAnnot = ah.createAnnotation(title, text, usernameOrig, password);
    267             } catch (UnknowUserException e1) {
    268                 setStatus(Status.CLIENT_ERROR_FORBIDDEN);
    269                 e1.printStackTrace();
    270                 return null;
    271             }
    272             try {
    273                 annot = new Annotation(xpointer, username, null, text, type, newAnnot.getString("node_uri"));
    274             } catch (JSONException e) {
    275                 // TODO Auto-generated catch block
    276                 e.printStackTrace();
    277                 setStatus(Status.SERVER_ERROR_INTERNAL);
    278                 return null;
    279             }
    280         } else
    281             annot = new Annotation(xpointer, username, null, text, type, url);
    282         return annot;
    283     }
    284 
    285121
    286122    /**
    … …  
    304140        if (!authenticated) {
    305141            setStatus(Status.CLIENT_ERROR_FORBIDDEN, "Not Authorized!");
    306             return null;           
     142            return null;
    307143        }
    308144
    309145        Annotation annot = null;
     146        AnnotationStore store = getAnnotationStore();
    310147        try {
    311148            JsonRepresentation jrep = new JsonRepresentation(entity);
    … …  
    315152                return null;
    316153            }
    317             RDFSearcher searcher = new RDFSearcher(NS.MPIWG_ANNOT_CTX); // TODO should ge into config file
    318154            // get stored Annotation
    319             List<Annotation> annots = searcher.searchById(id);
    320             if (annots.size() < 1) {
     155            Annotation storedAnnot = store.getAnnotationById(id);
     156            if (storedAnnot == null) {
    321157                setStatus(Status.CLIENT_ERROR_NOT_FOUND);
    322158                return null;
    323159            }
    324             Annotation storedAnnot = annots.get(0);
    325             // delete
    326             searcher.deleteById(id);
    327160            // update from posted JSON
    328161            annot = updateAnnotation(storedAnnot, jo, entity);
    329162            // store Annotation
    330             storedAnnot = new Convert(NS.MPIWG_ANNOT_CTX).storeAnnotation(annot);
    331             /* according to https://github.com/okfn/annotator/wiki/Storage
    332              * we should return 303: see other.
    333              * but the client doesn't like it
    334             setStatus(Status.REDIRECTION_SEE_OTHER);
    335             // go to same URL as this one
    336             Reference thisUrl = this.getReference();
    337             this.getResponse().setLocationRef(thisUrl); */
     163            storedAnnot = store.storeAnnotation(annot);
     164            /*
     165             * according to https://github.com/okfn/annotator/wiki/Storage we
     166             * should return 303: see other. but the client doesn't like it
     167             * setStatus(Status.REDIRECTION_SEE_OTHER); // go to same URL as
     168             * this one Reference thisUrl = this.getReference();
     169             * this.getResponse().setLocationRef(thisUrl);
     170            */
    338171            // return new annotation
    339172            jo = createAnnotatorJson(storedAnnot);
    340173            JsonRepresentation retRep = new JsonRepresentation(jo);
    341174            return retRep;
    342         } catch (TripleStoreHandlerException e) {
    343             e.printStackTrace();
    344             setStatus(Status.SERVER_ERROR_INTERNAL, "TripleStoreHandler Error");
    345         } catch (TripleStoreSearchError e) {
    346             e.printStackTrace();
    347             setStatus(Status.SERVER_ERROR_INTERNAL, "TripleStoreSearch Error");
    348175        } catch (JSONException e) {
    349176            e.printStackTrace();
    … …  
    376203        if (!authenticated) {
    377204            setStatus(Status.CLIENT_ERROR_FORBIDDEN, "Not Authorized!");
    378             return null;           
    379         }
    380        
    381         RDFSearcher searcher = new RDFSearcher(NS.MPIWG_ANNOT_CTX); // TODO should ge into config file
    382 
    383         try {
    384             // delete annotation
    385             searcher.deleteById(id);
    386             setStatus(Status.SUCCESS_NO_CONTENT);
    387         } catch (TripleStoreHandlerException e) {
    388             e.printStackTrace();
    389             setStatus(Status.SERVER_ERROR_INTERNAL, "TripleStoreHandler Error");
    390         } catch (TripleStoreSearchError e) {
    391             e.printStackTrace();
    392             setStatus(Status.SERVER_ERROR_INTERNAL, "TripleStoreSearch Error");
    393         }
     205            return null;
     206        }
     207
     208        // delete annotation
     209        getAnnotationStore().deleteById(id);
     210        setStatus(Status.SUCCESS_NO_CONTENT);
    394211        return null;
    395212    }
    396    
    397213
    398214}
Note: See TracChangeset for help on using the changeset viewer.