Examples with AuthenticatedUser edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser used on opensource projects

Example 31 with AuthenticatedUser

use of edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser in project dataverse by IQSS.

the class Datasets method returnToAuthor.

@POST
@Path("{id}/returnToAuthor")
public Response returnToAuthor(@PathParam("id") String idSupplied, String jsonBody) {
    if (jsonBody == null || jsonBody.isEmpty()) {
        return error(Response.Status.BAD_REQUEST, "You must supply JSON to this API endpoint and it must contain a reason for returning the dataset.");
    }
    StringReader rdr = new StringReader(jsonBody);
    JsonObject json = Json.createReader(rdr).readObject();
    try {
        Dataset dataset = findDatasetOrDie(idSupplied);
        String reasonForReturn = null;
        reasonForReturn = json.getString("reasonForReturn");
        // TODO: Once we add a box for the curator to type into, pass the reason for return to the ReturnDatasetToAuthorCommand and delete this check and call to setReturnReason on the API side.
        if (reasonForReturn == null || reasonForReturn.isEmpty()) {
            return error(Response.Status.BAD_REQUEST, "You must enter a reason for returning a dataset to the author(s).");
        }
        AuthenticatedUser authenticatedUser = findAuthenticatedUserOrDie();
        Dataset updatedDataset = execCommand(new ReturnDatasetToAuthorCommand(createDataverseRequest(authenticatedUser), dataset, reasonForReturn));
        boolean inReview = updatedDataset.isLockedFor(DatasetLock.Reason.InReview);
        JsonObjectBuilder result = Json.createObjectBuilder();
        result.add("inReview", inReview);
        result.add("message", "Dataset id " + updatedDataset.getId() + " has been sent back to the author(s).");
        return ok(result);
    } catch (WrappedResponse wr) {
        return wr.getResponse();
    }
}

Example 32 with AuthenticatedUser

use of edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser in project dataverse by IQSS.

the class SavedSearches method add.

@POST
public Response add(JsonObject body) {
    if (body == null) {
        return error(BAD_REQUEST, "JSON is expected.");
    }
    String keyForAuthenticatedUserId = "creatorId";
    long creatorIdToLookUp;
    try {
        creatorIdToLookUp = body.getInt(keyForAuthenticatedUserId);
    } catch (NullPointerException ex) {
        return error(BAD_REQUEST, "Required field missing: " + keyForAuthenticatedUserId);
    } catch (ClassCastException ex) {
        return error(BAD_REQUEST, "A number is required for " + keyForAuthenticatedUserId);
    } catch (Exception ex) {
        return error(BAD_REQUEST, "Problem with " + keyForAuthenticatedUserId + ": " + ex);
    }
    AuthenticatedUser creator = authSvc.findByID(creatorIdToLookUp);
    if (creator == null) {
        return error(Response.Status.NOT_FOUND, "Could not find user based on " + keyForAuthenticatedUserId + ": " + creatorIdToLookUp);
    }
    String keyForQuery = "query";
    String query;
    try {
        query = body.getString(keyForQuery);
    } catch (NullPointerException ex) {
        return error(BAD_REQUEST, "Required field missing: " + keyForQuery);
    }
    String keyForDefinitionPointId = "definitionPointId";
    long dataverseIdToLookup;
    try {
        dataverseIdToLookup = body.getInt(keyForDefinitionPointId);
    } catch (NullPointerException ex) {
        return error(BAD_REQUEST, "Required field missing: " + keyForDefinitionPointId);
    } catch (ClassCastException ex) {
        return error(BAD_REQUEST, "A number is required for " + keyForDefinitionPointId);
    } catch (Exception ex) {
        return error(BAD_REQUEST, "Problem with " + keyForDefinitionPointId + ": " + ex);
    }
    Dataverse definitionPoint = dataverseSvc.find(dataverseIdToLookup);
    if (definitionPoint == null) {
        return error(NOT_FOUND, "Could not find a dataverse based on id " + dataverseIdToLookup);
    }
    SavedSearch toPersist = new SavedSearch(query, definitionPoint, creator);
    String keyForFilterQueries = "filterQueries";
    List<SavedSearchFilterQuery> savedSearchFilterQuerys = new ArrayList<>();
    try {
        JsonArray filterQueries = body.getJsonArray(keyForFilterQueries);
        for (int i = 0; i < filterQueries.size(); i++) {
            String fq = filterQueries.getString(i);
            SavedSearchFilterQuery filterQuery = new SavedSearchFilterQuery(fq, toPersist);
            savedSearchFilterQuerys.add(filterQuery);
        }
    } catch (NullPointerException ex) {
    // filter queries are not required, keep going
    } catch (Exception ex) {
        return error(BAD_REQUEST, "Problem getting filter queries: " + ex);
    }
    if (!savedSearchFilterQuerys.isEmpty()) {
        toPersist.setSavedSearchFilterQueries(savedSearchFilterQuerys);
    }
    try {
        SavedSearch persistedSavedSearch = savedSearchSvc.add(toPersist);
        return ok("Added: " + persistedSavedSearch);
    } catch (EJBException ex) {
        StringBuilder errors = new StringBuilder();
        Throwable throwable = ex.getCause();
        while (throwable != null) {
            errors.append(throwable).append(" ");
            throwable = throwable.getCause();
        }
        return error(BAD_REQUEST, "Problem adding saved search: " + errors);
    }
}

Example 33 with AuthenticatedUser

use of edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser in project dataverse by IQSS.

the class WorldMapRelatedData method updateWorldMapLayerData.

/*
        For WorldMap/GeoConnect Usage
        Create/Updated a MapLayerMetadata object for a given Datafile id
        
        Example of jsonLayerData String:
        {
             "layerName": "geonode:boston_census_blocks_zip_cr9"
            , "layerLink": "http://localhost:8000/data/geonode:boston_census_blocks_zip_cr9"
            , "embedMapLink": "http://localhost:8000/maps/embed/?layer=geonode:boston_census_blocks_zip_cr9"
            , "worldmapUsername": "dv_pete"
        }
    */
@POST
@Path(UPDATE_MAP_LAYER_DATA_API_PATH_FRAGMENT)
public Response updateWorldMapLayerData(String jsonLayerData) {
    // ----------------------------------
    if (jsonLayerData == null) {
        logger.log(Level.SEVERE, "jsonLayerData is null");
        return error(Response.Status.BAD_REQUEST, "No JSON data");
    }
    // (1) Parse JSON
    // 
    JsonObject jsonInfo;
    try (StringReader rdr = new StringReader(jsonLayerData)) {
        jsonInfo = Json.createReader(rdr).readObject();
    } catch (JsonParsingException jpe) {
        logger.log(Level.SEVERE, "Json: " + jsonLayerData);
        return error(Response.Status.BAD_REQUEST, "Error parsing Json: " + jpe.getMessage());
    }
    // Retrieve token string
    String worldmapTokenParam = this.retrieveTokenValueFromJson(jsonInfo);
    if (worldmapTokenParam == null) {
        return error(Response.Status.BAD_REQUEST, "Token not found in JSON request.");
    }
    // Retrieve WorldMapToken and make sure it is valid
    // 
    WorldMapToken wmToken = this.tokenServiceBean.retrieveAndRefreshValidToken(worldmapTokenParam);
    if (wmToken == null) {
        return error(Response.Status.UNAUTHORIZED, "No access. Invalid token.");
    }
    // 
    if (!(tokenServiceBean.canTokenUserEditFile(wmToken))) {
        tokenServiceBean.expireToken(wmToken);
        return error(Response.Status.UNAUTHORIZED, "No access. Invalid token.");
    }
    // 
    for (String attr : MapLayerMetadata.MANDATORY_JSON_FIELDS) {
        if (!jsonInfo.containsKey(attr)) {
            return error(Response.Status.BAD_REQUEST, "Error parsing Json.  Key not found [" + attr + "]\nRequired keys are: " + MapLayerMetadata.MANDATORY_JSON_FIELDS);
        }
    }
    // (3) Attempt to retrieve DataverseUser
    AuthenticatedUser dvUser = wmToken.getDataverseUser();
    if (dvUser == null) {
        return error(Response.Status.NOT_FOUND, "DataverseUser not found for token");
    }
    // (4) Attempt to retrieve DataFile
    DataFile dfile = wmToken.getDatafile();
    if (dfile == null) {
        return error(Response.Status.NOT_FOUND, "DataFile not found for token");
    }
    // check permissions!
    if (!permissionService.request(createDataverseRequest(dvUser)).on(dfile.getOwner()).has(Permission.EditDataset)) {
        String errMsg = "The user does not have permission to edit metadata for this file. (MapLayerMetadata)";
        return error(Response.Status.FORBIDDEN, errMsg);
    }
    // (5) See if a MapLayerMetadata already exists
    // 
    MapLayerMetadata mapLayerMetadata = this.mapLayerMetadataService.findMetadataByDatafile(dfile);
    if (mapLayerMetadata == null) {
        // Create a new mapLayerMetadata object
        mapLayerMetadata = new MapLayerMetadata();
    }
    // Create/Update new MapLayerMetadata object and save it
    mapLayerMetadata.setDataFile(dfile);
    mapLayerMetadata.setDataset(dfile.getOwner());
    mapLayerMetadata.setLayerName(jsonInfo.getString("layerName"));
    mapLayerMetadata.setLayerLink(jsonInfo.getString("layerLink"));
    mapLayerMetadata.setEmbedMapLink(jsonInfo.getString("embedMapLink"));
    mapLayerMetadata.setWorldmapUsername(jsonInfo.getString("worldmapUsername"));
    if (jsonInfo.containsKey("mapImageLink")) {
        mapLayerMetadata.setMapImageLink(jsonInfo.getString("mapImageLink"));
    }
    // If this was a tabular join set the attributes:
    // - isJoinLayer
    // - joinDescription
    // 
    String joinDescription = jsonInfo.getString("joinDescription", null);
    if ((joinDescription == null) || (joinDescription.equals(""))) {
        mapLayerMetadata.setIsJoinLayer(true);
        mapLayerMetadata.setJoinDescription(joinDescription);
    } else {
        mapLayerMetadata.setIsJoinLayer(false);
        mapLayerMetadata.setJoinDescription(null);
    }
    // Set the mapLayerLinks
    // 
    String mapLayerLinks = jsonInfo.getString("mapLayerLinks", null);
    if ((mapLayerLinks == null) || (mapLayerLinks.equals(""))) {
        mapLayerMetadata.setMapLayerLinks(null);
    } else {
        mapLayerMetadata.setMapLayerLinks(mapLayerLinks);
    }
    // mapLayer.save();
    MapLayerMetadata savedMapLayerMetadata = mapLayerMetadataService.save(mapLayerMetadata);
    if (savedMapLayerMetadata == null) {
        logger.log(Level.SEVERE, "Json: " + jsonLayerData);
        return error(Response.Status.BAD_REQUEST, "Failed to save map layer!  Original JSON: ");
    }
    // notify user
    userNotificationService.sendNotification(dvUser, wmToken.getCurrentTimestamp(), UserNotification.Type.MAPLAYERUPDATED, dfile.getOwner().getLatestVersion().getId());
    // ------------------------------------------
    try {
        logger.info("retrieveMapImageForIcon");
        this.mapLayerMetadataService.retrieveMapImageForIcon(savedMapLayerMetadata);
    } catch (IOException ex) {
        logger.severe("Failed to retrieve image from WorldMap server");
        Logger.getLogger(WorldMapRelatedData.class.getName()).log(Level.SEVERE, null, ex);
    }
    return ok("map layer object saved!");
}

Example 34 with AuthenticatedUser

use of edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser in project dataverse by IQSS.

the class WorldMapRelatedData method mapDataFileTokenOnlyOption.

/*
        Link used within Dataverse for MapIt button
        Sends file link to GeoConnect using a Redirect
    
    */
// @GET
// @Path( MAP_IT_API_PATH_FRAGMENT + "token-option/{datafile_id}/{dvuser_id}/{token_only}")
private Response mapDataFileTokenOnlyOption(@Context HttpServletRequest request, Long datafile_id, Long dvuser_id, boolean tokenOnly) {
    logger.log(Level.INFO, "mapDataFile datafile_id: {0}", datafile_id);
    logger.log(Level.INFO, "mapDataFile dvuser_id: {0}", dvuser_id);
    AuthenticatedUser user = null;
    if (session != null) {
        if (session.getUser() != null) {
            if (session.getUser().isAuthenticated()) {
                user = (AuthenticatedUser) session.getUser();
            }
        }
    }
    if (user == null) {
        return error(Response.Status.FORBIDDEN, "Not logged in");
    }
    if (true) {
    // return okResponse( "Looks good " + datafile_id);
    // tokenAppServiceBean.getGeoConnectApplication();
    // return okResponse("Currently deactivated (mapDataFile)");
    }
    // Check if the user exists
    AuthenticatedUser dvUser = dataverseUserService.findByID(dvuser_id);
    if (dvUser == null) {
        return error(Response.Status.FORBIDDEN, "Invalid user");
    }
    // Check if this file exists
    DataFile dfile = dataFileService.find(datafile_id);
    if (dfile == null) {
        return error(Response.Status.NOT_FOUND, "DataFile not found for id: " + datafile_id);
    }
    /*
            Is the dataset public?
        */
    if (!dfile.getOwner().isReleased()) {
        return error(Response.Status.FORBIDDEN, "Mapping is only permitted for public datasets/files");
    }
    // Does this user have permission to edit metadata for this file?
    if (!permissionService.request(createDataverseRequest(dvUser)).on(dfile.getOwner()).has(Permission.EditDataset)) {
        String errMsg = "The user does not have permission to edit metadata for this file.";
        return error(Response.Status.FORBIDDEN, errMsg);
    }
    WorldMapToken token = tokenServiceBean.getNewToken(dfile, dvUser);
    if (tokenOnly) {
        // Return only the token in a JSON object
        final JsonObjectBuilder jsonInfo = Json.createObjectBuilder();
        jsonInfo.add(WorldMapToken.GEOCONNECT_TOKEN_KEY, token.getToken());
        return ok(jsonInfo);
    }
    // Redirect to geoconnect url
    String callback_url = systemConfig.getDataverseSiteUrl() + GET_WORLDMAP_DATAFILE_API_PATH;
    String redirect_url_str = token.getApplication().getMapitLink() + "/" + token.getToken() + "/?cb=" + URLEncoder.encode(callback_url);
    URI redirect_uri;
    try {
        redirect_uri = new URI(redirect_url_str);
    } catch (URISyntaxException ex) {
        return error(Response.Status.NOT_FOUND, "Faile to create URI from: " + redirect_url_str);
    }
    // Response.
    return Response.seeOther(redirect_uri).build();
}

Example 35 with AuthenticatedUser

use of edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser in project dataverse by IQSS.

the class WorldMapRelatedData method getWorldMapDatafileInfo.

/**
 * Retrieve FileMetadata for Use by WorldMap.
 *  This includes information about the DataFile, Dataset, DatasetVersion, and Dataverse
 *
 * @param jsonTokenData
 * @param request
 * @return
 */
@POST
// + "{worldmap_token}")
@Path(GET_WORLDMAP_DATAFILE_API_PATH_FRAGMENT)
public Response getWorldMapDatafileInfo(String jsonTokenData, @Context HttpServletRequest request) {
    // , @PathParam("worldmap_token") String worldmapTokenParam) {
    if (true) {
    // return okResponse("Currently deactivated");
    // return okResponse("remote server: " + request.getRemoteAddr());
    }
    logger.info("API call: getWorldMapDatafileInfo");
    // ----------------------------------
    // Auth check: Parse the json message and check for a valid GEOCONNECT_TOKEN_KEY and GEOCONNECT_TOKEN_VALUE
    // -- For testing, the GEOCONNECT_TOKEN_VALUE will be dynamic, found in the db
    // ----------------------------------
    logger.info("(1) jsonTokenData: " + jsonTokenData);
    // Parse JSON
    JsonObject jsonTokenInfo;
    try (StringReader rdr = new StringReader(jsonTokenData)) {
        jsonTokenInfo = Json.createReader(rdr).readObject();
    } catch (JsonParsingException jpe) {
        logger.log(Level.SEVERE, "Json: " + jsonTokenData);
        return error(Response.Status.BAD_REQUEST, "Error parsing Json: " + jpe.getMessage());
    }
    logger.info("(1a) jsonTokenInfo: " + jsonTokenInfo);
    // Retrieve token string
    String worldmapTokenParam = this.retrieveTokenValueFromJson(jsonTokenInfo);
    logger.info("(1b) token from JSON: " + worldmapTokenParam);
    if (worldmapTokenParam == null) {
        return error(Response.Status.BAD_REQUEST, "Token not found in JSON request.");
    }
    // Retrieve WorldMapToken and make sure it is valid
    // 
    WorldMapToken wmToken = tokenServiceBean.retrieveAndRefreshValidToken(worldmapTokenParam);
    logger.info("(2) token retrieved from db: " + wmToken);
    if (wmToken == null) {
        return error(Response.Status.UNAUTHORIZED, "No access. Invalid token.");
    }
    // Make sure the token's User still has permissions to access the file
    // 
    logger.info("(3) check permissions");
    if (!(tokenServiceBean.canTokenUserEditFile(wmToken))) {
        tokenServiceBean.expireToken(wmToken);
        return error(Response.Status.UNAUTHORIZED, "No access. Invalid token.");
    }
    // (1) Retrieve token connected data: DataverseUser, DataFile
    // 
    // Make sure token user and file are still available
    // 
    AuthenticatedUser dvUser = wmToken.getDataverseUser();
    if (dvUser == null) {
        return error(Response.Status.NOT_FOUND, "DataverseUser not found for token");
    }
    DataFile dfile = wmToken.getDatafile();
    if (dfile == null) {
        return error(Response.Status.NOT_FOUND, "DataFile not found for token");
    }
    // (1a) Retrieve FileMetadata
    FileMetadata dfile_meta = dfile.getFileMetadata();
    if (dfile_meta == null) {
        return error(Response.Status.NOT_FOUND, "FileMetadata not found");
    }
    // (2) Now get the dataset and the latest DatasetVersion
    Dataset dset = dfile.getOwner();
    if (dset == null) {
        return error(Response.Status.NOT_FOUND, "Owning Dataset for this DataFile not found");
    }
    // (2a) latest DatasetVersion
    // !! How do you check if the lastest version has this specific file?
    // 
    DatasetVersion dset_version = dset.getLatestVersion();
    if (dset_version == null) {
        return error(Response.Status.NOT_FOUND, "Latest DatasetVersion for this DataFile not found");
    }
    // (3) get Dataverse
    Dataverse dverse = dset.getOwner();
    if (dverse == null) {
        return error(Response.Status.NOT_FOUND, "Dataverse for this DataFile's Dataset not found");
    }
    // (4) Roll it all up in a JSON response
    final JsonObjectBuilder jsonData = Json.createObjectBuilder();
    // ------------------------------------
    if (dfile.isShapefileType()) {
        jsonData.add("mapping_type", "shapefile");
    } else if (dfile.isTabularData()) {
        jsonData.add("mapping_type", "tabular");
    } else {
        logger.log(Level.SEVERE, "This was neither a Shapefile nor a Tabular data file.  DataFile id: " + dfile.getId());
        return error(Response.Status.BAD_REQUEST, "Sorry! This file does not have mapping data. Please contact the Dataverse administrator. DataFile id: " + dfile.getId());
    }
    // ------------------------------------
    // DataverseUser Info
    // ------------------------------------
    jsonData.add("dv_user_id", dvUser.getId());
    jsonData.add("dv_username", dvUser.getUserIdentifier());
    jsonData.add("dv_user_email", dvUser.getEmail());
    // ------------------------------------
    // Dataverse URLs to this server
    // ------------------------------------
    String serverName = systemConfig.getDataverseSiteUrl();
    jsonData.add("return_to_dataverse_url", dset_version.getReturnToFilePageURL(serverName, dset, dfile));
    jsonData.add("datafile_download_url", dfile.getMapItFileDownloadURL(serverName));
    // ------------------------------------
    // Dataverse
    // ------------------------------------
    // jsonData.add("dataverse_installation_name", "Harvard Dataverse"); // todo / fix
    // is this enough to distinguish a dataverse installation?
    jsonData.add("dataverse_installation_name", systemConfig.getDataverseSiteUrl());
    jsonData.add("dataverse_id", dverse.getId());
    jsonData.add("dataverse_name", dverse.getName());
    String dataverseDesc = dverse.getDescription();
    if (dataverseDesc == null || dataverseDesc.equalsIgnoreCase("")) {
        dataverseDesc = "";
    }
    jsonData.add("dataverse_description", dataverseDesc);
    // ------------------------------------
    // Dataset Info
    // ------------------------------------
    jsonData.add("dataset_id", dset.getId());
    // ------------------------------------
    // DatasetVersion Info
    // ------------------------------------
    // database id
    jsonData.add("dataset_version_id", dset_version.getId());
    // major/minor version number, e.g. 3.1
    jsonData.add("dataset_semantic_version", dset_version.getSemanticVersion());
    jsonData.add("dataset_name", dset_version.getTitle());
    jsonData.add("dataset_citation", dset_version.getCitation(true));
    // Need to fix to/do
    jsonData.add("dataset_description", "");
    jsonData.add("dataset_is_public", dset_version.isReleased());
    // ------------------------------------
    // DataFile/FileMetaData Info
    // ------------------------------------
    jsonData.add("datafile_id", dfile.getId());
    jsonData.add("datafile_label", dfile_meta.getLabel());
    // jsonData.add("filename", dfile_meta.getLabel());
    jsonData.add("datafile_expected_md5_checksum", dfile.getChecksumValue());
    Long fsize = dfile.getFilesize();
    if (fsize == null) {
        fsize = new Long(-1);
    }
    jsonData.add("datafile_filesize", fsize);
    jsonData.add("datafile_content_type", dfile.getContentType());
    jsonData.add("datafile_create_datetime", dfile.getCreateDate().toString());
    // restriction status of the DataFile
    jsonData.add("datafile_is_restricted", dfile.isRestricted());
    return ok(jsonData);
}