#22693

Committed 03 Jul 2024 01:09PM CUT coverage: 20.626% (-0.09%) from 20.716%

Build # #22693

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #10664 from IQSS/develop

merge develop into master for 6.3

Run Details

195 of 1852 new or added lines in 82 files covered. (10.53%)

72 existing lines in 33 files now uncovered.

17335 of 84043 relevant lines covered (20.63%)

0.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/edu/harvard/iq/dataverse/mydata/DataRetrieverAPI.java

/**
 * @todo Shouldn't this be in the "edu.harvard.iq.dataverse.api" package? Is the only one that isn't.
 */
package edu.harvard.iq.dataverse.mydata;

import edu.harvard.iq.dataverse.DatasetServiceBean;
import edu.harvard.iq.dataverse.DataverseRoleServiceBean;
import edu.harvard.iq.dataverse.DataverseServiceBean;
import edu.harvard.iq.dataverse.DataverseSession;
import edu.harvard.iq.dataverse.DvObject;
import edu.harvard.iq.dataverse.DvObjectServiceBean;
import edu.harvard.iq.dataverse.RoleAssigneeServiceBean;
import edu.harvard.iq.dataverse.api.auth.AuthRequired;
import edu.harvard.iq.dataverse.search.SearchServiceBean;
import edu.harvard.iq.dataverse.search.SolrQueryResponse;
import edu.harvard.iq.dataverse.search.SolrSearchResult;
import edu.harvard.iq.dataverse.api.AbstractApiBean;
import edu.harvard.iq.dataverse.authorization.AuthenticationServiceBean;
import edu.harvard.iq.dataverse.authorization.DataverseRole;
import edu.harvard.iq.dataverse.authorization.DataverseRolePermissionHelper;
//import edu.harvard.iq.dataverse.authorization.MyDataQueryHelperServiceBean;
import edu.harvard.iq.dataverse.authorization.groups.GroupServiceBean;
import edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser;
import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
import edu.harvard.iq.dataverse.search.SearchConstants;
import edu.harvard.iq.dataverse.search.SearchException;
import edu.harvard.iq.dataverse.search.SearchFields;
import edu.harvard.iq.dataverse.search.SortBy;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
import jakarta.ejb.EJB;
import jakarta.inject.Inject;
import jakarta.json.Json;
import jakarta.json.JsonArrayBuilder;
import jakarta.json.JsonObjectBuilder;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.container.ContainerRequestContext;
import jakarta.ws.rs.core.Context;

import edu.harvard.iq.dataverse.util.BundleUtil;
import org.apache.commons.lang3.StringUtils;

/**
 *
 * @author rmp553
 * 
 *  The primary method here is this API endpoint: retrieveMyDataAsJsonString
 *
 *  - This method validates the current logged in user
 * 
 */
@Path("mydata")
public class DataRetrieverAPI extends AbstractApiBean {

    private static final Logger logger = Logger.getLogger(DataRetrieverAPI.class.getCanonicalName());

    public static final String retrieveDataFullAPIPath = "/api/v1/mydata/retrieve";
    private static final String retrieveDataPartialAPIPath = "retrieve";

    @Inject
    DataverseSession session;

    @EJB
    DataverseRoleServiceBean dataverseRoleService;
    @EJB
    RoleAssigneeServiceBean roleAssigneeService;
    @EJB
    DvObjectServiceBean dvObjectServiceBean;
    @EJB
    SearchServiceBean searchService;
    @EJB
    AuthenticationServiceBean authenticationService;
    @EJB
    DataverseServiceBean dataverseService;
    //@EJB
    //MyDataQueryHelperServiceBean myDataQueryHelperServiceBean;
    @EJB
    GroupServiceBean groupService;
    @EJB
    DatasetServiceBean datasetService;
    
    private List<DataverseRole> roleList;
    private DataverseRolePermissionHelper rolePermissionHelper;
    private MyDataFinder myDataFinder;
    private SolrQueryResponse solrQueryResponse;
    private AuthenticatedUser authUser = null;

    public static final String JSON_SUCCESS_FIELD_NAME = "success";
    public static final String JSON_ERROR_MSG_FIELD_NAME = "error_message";
    public static final String JSON_DATA_FIELD_NAME = "data";

    /**
     * Constructor
     * 
     */
    public DataRetrieverAPI(){
           
    }
    
    public String getRetrieveDataFullAPIPath(){
        return DataRetrieverAPI.retrieveDataFullAPIPath;
    }
    
    public Pager getRandomPagerPager(Integer selectedPage){
        if (selectedPage == null){
            selectedPage = 1;
        }
        
        int itemsPerPage = 10;
        int numResults = 108;//randInt(1,200);
        int numPages =  numResults / itemsPerPage;
        if ((numResults % itemsPerPage) > 0){
            numPages++;
        }
        int chosenPage = 1;
        if ((selectedPage > numPages)||(selectedPage < 1)){
            chosenPage = 1;
        }else{
            chosenPage = selectedPage;
        }
        //int chosenPage = max(randInt(0, numPages), 1);
        return new Pager(numResults, itemsPerPage, chosenPage);
                
    }
    
    /*
    @Path("test-it2")
    @GET
    @Produces({"application/json"})
    public String retrieveTestPager(@QueryParam("selectedPage") int selectedPage){
        
        return this.getRandomPagerPager(selectedPage).asJSONString();
    }
    */
    //private String getUserIdentifier()
    
    
    public boolean isSuperuser(){
        return (session.getUser() != null) && session.getUser().isSuperuser();
    }
    
    private AuthenticatedUser getUserFromIdentifier(String userIdentifier){
        
        if ((userIdentifier==null)||(userIdentifier.isEmpty())){
            return null;
        }
        return authenticationService.getAuthenticatedUser(userIdentifier);
    }
    
    public Map<String, Long> getTotalCountsFromSolrAsJavaMap(DataverseRequest dataverseRequest, MyDataFinder myDataFinder ){
        //msgt("getTotalCountsFromSolrAsJavaMap: " + searchUser.getIdentifier());
        SolrQueryResponse solrQueryResponseForCounts = getTotalCountsFromSolr(dataverseRequest, myDataFinder);
        if (solrQueryResponseForCounts == null){
            logger.severe("DataRetrieverAPI.getTotalCountsFromSolrAsJSON: solrQueryResponseForCounts should not be null");
            return null;
        }
        return solrQueryResponseForCounts.getDvObjectCounts();
    }
    
    public JsonObjectBuilder getTotalCountsFromSolrAsJSON(DataverseRequest dataverseRequest, MyDataFinder myDataFinder ){
    
        SolrQueryResponse solrQueryResponseForCounts = getTotalCountsFromSolr(dataverseRequest, myDataFinder);
        if (solrQueryResponseForCounts == null){
            logger.severe("DataRetrieverAPI.getTotalCountsFromSolrAsJSON: solrQueryResponseForCounts should not be null");
            return null;
        }
        return solrQueryResponseForCounts.getDvObjectCountsAsJSON();
    }
    
    
    private SolrQueryResponse getTotalCountsFromSolr(DataverseRequest dataverseRequest, MyDataFinder myDataFinder){
        //msgt("getTotalCountsFromSolr: " + searchUser.getIdentifier());

        if (myDataFinder == null){
            throw new NullPointerException("myDataFinder cannot be null");
        }
        if (dataverseRequest == null){
            throw new NullPointerException("dataverseRequest cannot be null");
        }
        
        // -------------------------------------------------------
        // Create new filter params that only check by the User 
        // -------------------------------------------------------
        MyDataFilterParams filterParams = new MyDataFilterParams(dataverseRequest, myDataFinder.getRolePermissionHelper());
        if (filterParams.hasError()){
            logger.severe("getTotalCountsFromSolr. filterParams error: " + filterParams.getErrorMessage());           
            return null;
        }
       
        // -------------------------------------------------------
        // Re-run all of the entity queries (sigh)
        // -------------------------------------------------------
        myDataFinder.initFields();
        myDataFinder.runFindDataSteps(filterParams);
        if (myDataFinder.hasError()){
            logger.severe("getTotalCountsFromSolr. myDataFinder error: " + myDataFinder.getErrorMessage());           
            return null;            
        }
        
        // -------------------------------------------------------
        // Generate filterQueries for total counts
        // -------------------------------------------------------
        List<String> filterQueries = myDataFinder.getSolrFilterQueriesForTotalCounts();
        if (filterQueries==null){
            logger.severe("getTotalCountsFromSolr. filterQueries was null!");
            return null;
        }
        //msgt("getTotalCountsFromSolr");
        //msgt(StringUtils.join(filterQueries, " AND "));
        
        // -------------------------------------------------------
        // Run Solr
        // -------------------------------------------------------
        SolrQueryResponse solrQueryResponseForCounts;
        try {
            solrQueryResponseForCounts = searchService.search(
                    dataverseRequest,
                    null, // subtree, default it to Dataverse for now
                    "*",  //    Get everything--always
                    filterQueries,//filterQueries,
                    SearchFields.NAME_SORT, SortBy.ASCENDING,
                    //SearchFields.RELEASE_OR_CREATE_DATE, SortBy.DESCENDING,
                    0, //paginationStart,
                    true, // dataRelatedToMe
                    SearchConstants.NUM_SOLR_DOCS_TO_RETRIEVE, //10 // SearchFields.NUM_SOLR_DOCS_TO_RETRIEVE
                    true, 
                    null,
                    null,
                    false, // no need to request facets here ...
                    false  // ... same for highlights
            );
        } catch (SearchException ex) {
            logger.severe("Search for total counts failed with filter query");
            logger.severe("filterQueries: " + StringUtils.join(filterQueries, "(separator)"));
            return null;
        }
        return solrQueryResponseForCounts;
    }
    
    private String getJSONErrorString(String jsonMsg, String optionalLoggerMsg){
        
        if (jsonMsg == null){
            throw new NullPointerException("jsonMsg cannot be null");
        }
        if (optionalLoggerMsg != null){
            logger.severe(optionalLoggerMsg);
        }
        JsonObjectBuilder jsonData = Json.createObjectBuilder();
        
        jsonData.add(DataRetrieverAPI.JSON_SUCCESS_FIELD_NAME, false);
        jsonData.add(DataRetrieverAPI.JSON_ERROR_MSG_FIELD_NAME, jsonMsg);
        
        return jsonData.build().toString();
        
    }


    @GET
    @AuthRequired
    @Path(retrieveDataPartialAPIPath)
    @Produces({"application/json"})
    public String retrieveMyDataAsJsonString(
            @Context ContainerRequestContext crc,
            @QueryParam("dvobject_types") List<DvObject.DType> dvobject_types,
            @QueryParam("published_states") List<String> published_states, 
            @QueryParam("selected_page") Integer selectedPage, 
            @QueryParam("mydata_search_term") String searchTerm,             
            @QueryParam("role_ids") List<Long> roleIds, 
            @QueryParam("userIdentifier") String userIdentifier,
            @QueryParam("filter_validities") Boolean filterValidities,
            @QueryParam("dataset_valid") List<Boolean> datasetValidities) {
        boolean OTHER_USER = false;

        String noMsgResultsFound = BundleUtil.getStringFromBundle("dataretrieverAPI.noMsgResultsFound");

        if ((session.getUser() != null) && (session.getUser().isAuthenticated())) {
            authUser = (AuthenticatedUser) session.getUser();
        } else {
            try {
                authUser = getRequestAuthenticatedUserOrDie(crc);
            } catch (WrappedResponse e) {
                return this.getJSONErrorString(
                    BundleUtil.getStringFromBundle("dataretrieverAPI.authentication.required"),
                    BundleUtil.getStringFromBundle("dataretrieverAPI.authentication.required.opt")
                );
            }
        }

        // For superusers, the searchUser may differ from the authUser
        AuthenticatedUser searchUser = null;
        // If the user is a superuser, see if a userIdentifier has been specified and use that instead
        if ((authUser.isSuperuser()) && (userIdentifier != null) && (!userIdentifier.isEmpty())) {
            searchUser = getUserFromIdentifier(userIdentifier);
            if (searchUser != null) {
                authUser = searchUser;
                OTHER_USER = true;
            } else {
                return this.getJSONErrorString(
                        BundleUtil.getStringFromBundle("dataretrieverAPI.user.not.found", Arrays.asList(userIdentifier)),
                        null);
            }
        }

        roleList = dataverseRoleService.findAll();
        rolePermissionHelper = new DataverseRolePermissionHelper(roleList);    
        
       
        List<DvObject.DType> dtypes;
        if (dvobject_types != null){
            dtypes = dvobject_types;
        }else{
            dtypes = MyDataFilterParams.defaultDvObjectTypes;
        }
        List<String> pub_states = null;
        if (published_states != null){
            pub_states = published_states;
        }
        List<Boolean> validities = null;
        if (filterValidities != null && filterValidities){
            validities = datasetValidities;
        }
        
        // ---------------------------------
        // (1) Initialize filterParams and check for Errors 
        // ---------------------------------
        DataverseRequest dataverseRequest = createDataverseRequest(authUser);

        
        MyDataFilterParams filterParams = new MyDataFilterParams(dataverseRequest, dtypes, pub_states, roleIds, searchTerm, validities);
        if (filterParams.hasError()){
            return this.getJSONErrorString(filterParams.getErrorMessage(), filterParams.getErrorMessage());
        }
       
        // ---------------------------------
        // (2) Initialize MyDataFinder and check for Errors 
        // ---------------------------------
        myDataFinder = new MyDataFinder(rolePermissionHelper,
                                        roleAssigneeService,
                                        dvObjectServiceBean, 
                                        groupService);
        this.myDataFinder.runFindDataSteps(filterParams);
        if (myDataFinder.hasError()){
            return this.getJSONErrorString(myDataFinder.getErrorMessage(), myDataFinder.getErrorMessage());
        }

        // ---------------------------------
        // (3) Make Solr Query
        // ---------------------------------
        int paginationStart = 1;
        if (selectedPage != null){
            paginationStart = selectedPage;
        }
        int solrCardStart = (paginationStart - 1) * SearchConstants.NUM_SOLR_DOCS_TO_RETRIEVE;
       
        // Default the searchUser to the authUser.
        // The exception: for logged-in superusers, the searchUser may differ from the authUser
        //
        if (searchUser == null){
            searchUser = authUser;
        }

        //msg("search with user: " + searchUser.getIdentifier());

        List<String> filterQueries = this.myDataFinder.getSolrFilterQueries();
        if (filterQueries==null){
            logger.fine("No ids found for this search");
            return this.getJSONErrorString(noMsgResultsFound, null);
        }
        //msgt("myDataFinder.getSolrFilterQueries(): " + myDataFinder.getSolrFilterQueries().toString());
        
        //msg("Selected paginationStart: " + paginationStart);

        try {
                solrQueryResponse = searchService.search(
                        dataverseRequest,
                        null, // subtree, default it to Dataverse for now
                        filterParams.getSearchTerm(),  //"*", //
                        filterQueries,//filterQueries,
                        //SearchFields.NAME_SORT, SortBy.ASCENDING,
                        SearchFields.RELEASE_OR_CREATE_DATE, SortBy.DESCENDING,
                        solrCardStart, //paginationStart,
                        true, // dataRelatedToMe
                        SearchConstants.NUM_SOLR_DOCS_TO_RETRIEVE //10 // SearchFields.NUM_SOLR_DOCS_TO_RETRIEVE
                );
                
                //msgt("getResultsStart: " + this.solrQueryResponse.getResultsStart());
                //msgt("getNumResultsFound: " + this.solrQueryResponse.getNumResultsFound());
                //msgt("getSolrSearchResults: " + this.solrQueryResponse.getSolrSearchResults().toString());
                if (this.solrQueryResponse.getNumResultsFound()==0){
                    return this.getJSONErrorString(noMsgResultsFound, null);
                }                
                         
        } catch (SearchException ex) {
            solrQueryResponse = null;   
            logger.severe("Solr SearchException: " + ex.getMessage());
        }
        
        if (solrQueryResponse == null) {
            return this.getJSONErrorString(
                BundleUtil.getStringFromBundle("dataretrieverAPI.solr.error"),
                BundleUtil.getStringFromBundle("dataretrieverAPI.solr.error.opt")
            );
        }
                
         // ---------------------------------
        // (4) Build JSON document including:
        //      - Pager
        //      - Formatted solr docs
        //      - Num results found
        //      - Search term
        //      - DvObject counts
        // ---------------------------------

        // Initialize JSON response
        JsonObjectBuilder jsonData = Json.createObjectBuilder();

        Pager pager = new Pager(solrQueryResponse.getNumResultsFound().intValue(), 
                                SearchConstants.NUM_SOLR_DOCS_TO_RETRIEVE, 
                                paginationStart);
        
        RoleTagRetriever roleTagRetriever = new RoleTagRetriever(this.rolePermissionHelper, this.roleAssigneeSvc, this.dvObjectServiceBean);
        roleTagRetriever.loadRoles(dataverseRequest, solrQueryResponse);

                
        jsonData.add(DataRetrieverAPI.JSON_SUCCESS_FIELD_NAME, true)
                .add(DataRetrieverAPI.JSON_DATA_FIELD_NAME,        
                        Json.createObjectBuilder()
                                .add("pagination", pager.asJsonObjectBuilderUsingCardTerms())
                                //.add(SearchConstants.SEARCH_API_ITEMS, this.formatSolrDocs(solrQueryResponse, filterParams, this.myDataFinder))
                                .add(SearchConstants.SEARCH_API_ITEMS, this.formatSolrDocs(solrQueryResponse, roleTagRetriever))
                                .add(SearchConstants.SEARCH_API_TOTAL_COUNT, solrQueryResponse.getNumResultsFound())
                                .add(SearchConstants.SEARCH_API_START, solrQueryResponse.getResultsStart())
                                .add("search_term",  filterParams.getSearchTerm())
                                .add("dvobject_counts", this.getDvObjectTypeCounts(solrQueryResponse))
                                .add("pubstatus_counts", this.getPublicationStatusCounts(solrQueryResponse))
                                .add("selected_filters", this.myDataFinder.getSelectedFilterParamsAsJSON())
            );

        // ---------------------------------------------------------
        // We're doing ~another~ solr query here
        // NOTE!  Do not reuse this.myDataFinder after this step!! It is being passed new filterParams
        // ---------------------------------------------------------
        //jsonData.add("total_dvobject_counts", getTotalCountsFromSolrAsJSON(searchUser, this.myDataFinder));

        
        if (OTHER_USER){
            jsonData.add("other_user", searchUser.getIdentifier());
        }
                                
        return jsonData.build().toString();
    }
   
    private JsonObjectBuilder getDvObjectTypeCounts(SolrQueryResponse solrResponse) {

        if (solrQueryResponse == null) {
            logger.severe("DataRetrieverAPI.getDvObjectTypeCounts: solrQueryResponse should not be null");
            return null;
        }
        return solrResponse.getDvObjectCountsAsJSON();
    }
    
    private JsonObjectBuilder getPublicationStatusCounts(SolrQueryResponse solrResponse) {

        if (solrQueryResponse == null) {
            logger.severe("DataRetrieverAPI.getDvObjectTypeCounts: solrQueryResponse should not be null");
            return null;
        }
        return solrResponse.getPublicationStatusCountsAsJSON();
    }
    
    /**
     * Using RoleTagRetriever to find role names for each card
     * Trying to minimize extra queries
     * 
     * @param solrResponse
     * @param roleTagRetriever
     * @return 
     */
    private JsonArrayBuilder formatSolrDocs(SolrQueryResponse solrResponse, RoleTagRetriever roleTagRetriever ){
        if (solrResponse == null){
            throw new NullPointerException("DataRetrieverAPI.formatSolrDocs:  solrResponse should not be null");     
        }
        if(roleTagRetriever==null){
            throw new NullPointerException("DataRetrieverAPI.formatSolrDocs:  roleTagRetriever should not be null");     
        }

        JsonArrayBuilder jsonSolrDocsArrayBuilder = Json.createArrayBuilder();

        JsonObjectBuilder myDataCardInfo;
        JsonArrayBuilder rolesForCard;
        
        for (SolrSearchResult doc : solrQueryResponse.getSolrSearchResults()){
            // -------------------------------------------
            // (a) Get core card data from solr
            // -------------------------------------------
            
            myDataCardInfo = doc.getJsonForMyData(isValid(doc));
            
            if (doc.getEntity() != null && !doc.getEntity().isInstanceofDataFile()){
                String parentAlias = dataverseService.getParentAliasString(doc);
                myDataCardInfo.add("parent_alias",parentAlias);
            }
            
            // -------------------------------------------
            // (b) Add role info
            // -------------------------------------------
            rolesForCard = roleTagRetriever.getRolesForCardAsJSON(doc.getEntityId());
            if (rolesForCard!=null){
                myDataCardInfo.add("user_roles", rolesForCard);
            }
            
            // -------------------------------------------
            // (c) Add final MyData JSON to array
            // -------------------------------------------
            jsonSolrDocsArrayBuilder.add(myDataCardInfo);
        }
        return jsonSolrDocsArrayBuilder;
        
    }

    private boolean isValid(SolrSearchResult result) {
        return result.isValid(x -> true);
    }
}        

1	/**
2	* @todo Shouldn't this be in the "edu.harvard.iq.dataverse.api" package? Is the only one that isn't.
3	*/
4	package edu.harvard.iq.dataverse.mydata;
5
6	import edu.harvard.iq.dataverse.DatasetServiceBean;
7	import edu.harvard.iq.dataverse.DataverseRoleServiceBean;
8	import edu.harvard.iq.dataverse.DataverseServiceBean;
9	import edu.harvard.iq.dataverse.DataverseSession;
10	import edu.harvard.iq.dataverse.DvObject;
11	import edu.harvard.iq.dataverse.DvObjectServiceBean;
12	import edu.harvard.iq.dataverse.RoleAssigneeServiceBean;
13	import edu.harvard.iq.dataverse.api.auth.AuthRequired;
14	import edu.harvard.iq.dataverse.search.SearchServiceBean;
15	import edu.harvard.iq.dataverse.search.SolrQueryResponse;
16	import edu.harvard.iq.dataverse.search.SolrSearchResult;
17	import edu.harvard.iq.dataverse.api.AbstractApiBean;
18	import edu.harvard.iq.dataverse.authorization.AuthenticationServiceBean;
19	import edu.harvard.iq.dataverse.authorization.DataverseRole;
20	import edu.harvard.iq.dataverse.authorization.DataverseRolePermissionHelper;
21	//import edu.harvard.iq.dataverse.authorization.MyDataQueryHelperServiceBean;
22	import edu.harvard.iq.dataverse.authorization.groups.GroupServiceBean;
23	import edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser;
24	import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
25	import edu.harvard.iq.dataverse.search.SearchConstants;
26	import edu.harvard.iq.dataverse.search.SearchException;
27	import edu.harvard.iq.dataverse.search.SearchFields;
28	import edu.harvard.iq.dataverse.search.SortBy;
29
30	import java.util.Arrays;
31	import java.util.List;
32	import java.util.Map;
33	import java.util.logging.Logger;
34	import jakarta.ejb.EJB;
35	import jakarta.inject.Inject;
36	import jakarta.json.Json;
37	import jakarta.json.JsonArrayBuilder;
38	import jakarta.json.JsonObjectBuilder;
39	import jakarta.ws.rs.GET;
40	import jakarta.ws.rs.Path;
41	import jakarta.ws.rs.Produces;
42	import jakarta.ws.rs.QueryParam;
43	import jakarta.ws.rs.container.ContainerRequestContext;
44	import jakarta.ws.rs.core.Context;
45
46	import edu.harvard.iq.dataverse.util.BundleUtil;
47	import org.apache.commons.lang3.StringUtils;
48
49	/**
50	*
51	* @author rmp553
52	*
53	* The primary method here is this API endpoint: retrieveMyDataAsJsonString
54	*
55	* - This method validates the current logged in user
56	*
57	*/
58	@Path("mydata")
59	public class DataRetrieverAPI extends AbstractApiBean {
60
61	private static final Logger logger = Logger.getLogger(DataRetrieverAPI.class.getCanonicalName());	×
62
63	public static final String retrieveDataFullAPIPath = "/api/v1/mydata/retrieve";
64	private static final String retrieveDataPartialAPIPath = "retrieve";
65
66	@Inject
67	DataverseSession session;
68
69	@EJB
70	DataverseRoleServiceBean dataverseRoleService;
71	@EJB
72	RoleAssigneeServiceBean roleAssigneeService;
73	@EJB
74	DvObjectServiceBean dvObjectServiceBean;
75	@EJB
76	SearchServiceBean searchService;
77	@EJB
78	AuthenticationServiceBean authenticationService;
79	@EJB
80	DataverseServiceBean dataverseService;
81	//@EJB
82	//MyDataQueryHelperServiceBean myDataQueryHelperServiceBean;
83	@EJB
84	GroupServiceBean groupService;
85	@EJB
86	DatasetServiceBean datasetService;
87
88	private List<DataverseRole> roleList;
89	private DataverseRolePermissionHelper rolePermissionHelper;
90	private MyDataFinder myDataFinder;
91	private SolrQueryResponse solrQueryResponse;
92	private AuthenticatedUser authUser = null;	×
93
94	public static final String JSON_SUCCESS_FIELD_NAME = "success";
95	public static final String JSON_ERROR_MSG_FIELD_NAME = "error_message";
96	public static final String JSON_DATA_FIELD_NAME = "data";
97
98	/**
99	* Constructor
100	*
101	*/
102	public DataRetrieverAPI(){	×
103
104	}	×
105
106	public String getRetrieveDataFullAPIPath(){
107	return DataRetrieverAPI.retrieveDataFullAPIPath;	×
108	}
109
110	public Pager getRandomPagerPager(Integer selectedPage){
111	if (selectedPage == null){	×
112	selectedPage = 1;	×
113	}
114
115	int itemsPerPage = 10;	×
116	int numResults = 108;//randInt(1,200);	×
117	int numPages = numResults / itemsPerPage;	×
118	if ((numResults % itemsPerPage) > 0){	×
119	numPages++;	×
120	}
121	int chosenPage = 1;	×
122	if ((selectedPage > numPages)\|\|(selectedPage < 1)){	×
123	chosenPage = 1;	×
124	}else{
125	chosenPage = selectedPage;	×
126	}
127	//int chosenPage = max(randInt(0, numPages), 1);
128	return new Pager(numResults, itemsPerPage, chosenPage);	×
129
130	}
131
132	/*
133	@Path("test-it2")
134	@GET
135	@Produces({"application/json"})
136	public String retrieveTestPager(@QueryParam("selectedPage") int selectedPage){
137
138	return this.getRandomPagerPager(selectedPage).asJSONString();
139	}
140	*/
141	//private String getUserIdentifier()
142
143
144	public boolean isSuperuser(){
145	return (session.getUser() != null) && session.getUser().isSuperuser();	×
146	}
147
148	private AuthenticatedUser getUserFromIdentifier(String userIdentifier){
149
150	if ((userIdentifier==null)\|\|(userIdentifier.isEmpty())){	×
151	return null;	×
152	}
153	return authenticationService.getAuthenticatedUser(userIdentifier);	×
154	}
155
156	public Map<String, Long> getTotalCountsFromSolrAsJavaMap(DataverseRequest dataverseRequest, MyDataFinder myDataFinder ){
157	//msgt("getTotalCountsFromSolrAsJavaMap: " + searchUser.getIdentifier());
158	SolrQueryResponse solrQueryResponseForCounts = getTotalCountsFromSolr(dataverseRequest, myDataFinder);	×
159	if (solrQueryResponseForCounts == null){	×
160	logger.severe("DataRetrieverAPI.getTotalCountsFromSolrAsJSON: solrQueryResponseForCounts should not be null");	×
161	return null;	×
162	}
163	return solrQueryResponseForCounts.getDvObjectCounts();	×
164	}
165
166	public JsonObjectBuilder getTotalCountsFromSolrAsJSON(DataverseRequest dataverseRequest, MyDataFinder myDataFinder ){
167
168	SolrQueryResponse solrQueryResponseForCounts = getTotalCountsFromSolr(dataverseRequest, myDataFinder);	×
169	if (solrQueryResponseForCounts == null){	×
170	logger.severe("DataRetrieverAPI.getTotalCountsFromSolrAsJSON: solrQueryResponseForCounts should not be null");	×
171	return null;	×
172	}
173	return solrQueryResponseForCounts.getDvObjectCountsAsJSON();	×
174	}
175
176
177	private SolrQueryResponse getTotalCountsFromSolr(DataverseRequest dataverseRequest, MyDataFinder myDataFinder){
178	//msgt("getTotalCountsFromSolr: " + searchUser.getIdentifier());
179
180	if (myDataFinder == null){	×
181	throw new NullPointerException("myDataFinder cannot be null");	×
182	}
183	if (dataverseRequest == null){	×
184	throw new NullPointerException("dataverseRequest cannot be null");	×
185	}
186
187	// -------------------------------------------------------
188	// Create new filter params that only check by the User
189	// -------------------------------------------------------
190	MyDataFilterParams filterParams = new MyDataFilterParams(dataverseRequest, myDataFinder.getRolePermissionHelper());	×
191	if (filterParams.hasError()){	×
192	logger.severe("getTotalCountsFromSolr. filterParams error: " + filterParams.getErrorMessage());	×
193	return null;	×
194	}
195
196	// -------------------------------------------------------
197	// Re-run all of the entity queries (sigh)
198	// -------------------------------------------------------
199	myDataFinder.initFields();	×
200	myDataFinder.runFindDataSteps(filterParams);	×
201	if (myDataFinder.hasError()){	×
202	logger.severe("getTotalCountsFromSolr. myDataFinder error: " + myDataFinder.getErrorMessage());	×
203	return null;	×
204	}
205
206	// -------------------------------------------------------
207	// Generate filterQueries for total counts
208	// -------------------------------------------------------
209	List<String> filterQueries = myDataFinder.getSolrFilterQueriesForTotalCounts();	×
210	if (filterQueries==null){	×
211	logger.severe("getTotalCountsFromSolr. filterQueries was null!");	×
212	return null;	×
213	}
214	//msgt("getTotalCountsFromSolr");
215	//msgt(StringUtils.join(filterQueries, " AND "));
216
217	// -------------------------------------------------------
218	// Run Solr
219	// -------------------------------------------------------
220	SolrQueryResponse solrQueryResponseForCounts;
221	try {
222	solrQueryResponseForCounts = searchService.search(	×
223	dataverseRequest,
224	null, // subtree, default it to Dataverse for now
225	"*", // Get everything--always
226	filterQueries,//filterQueries,
227	SearchFields.NAME_SORT, SortBy.ASCENDING,
228	//SearchFields.RELEASE_OR_CREATE_DATE, SortBy.DESCENDING,
229	0, //paginationStart,
230	true, // dataRelatedToMe
231	SearchConstants.NUM_SOLR_DOCS_TO_RETRIEVE, //10 // SearchFields.NUM_SOLR_DOCS_TO_RETRIEVE
232	true,
233	null,
234	null,
235	false, // no need to request facets here ...
236	false // ... same for highlights
237	);
238	} catch (SearchException ex) {	×
239	logger.severe("Search for total counts failed with filter query");	×
240	logger.severe("filterQueries: " + StringUtils.join(filterQueries, "(separator)"));	×
241	return null;	×
242	}	×
243	return solrQueryResponseForCounts;	×
244	}
245
246	private String getJSONErrorString(String jsonMsg, String optionalLoggerMsg){
247
248	if (jsonMsg == null){	×
249	throw new NullPointerException("jsonMsg cannot be null");	×
250	}
251	if (optionalLoggerMsg != null){	×
252	logger.severe(optionalLoggerMsg);	×
253	}
254	JsonObjectBuilder jsonData = Json.createObjectBuilder();	×
255
256	jsonData.add(DataRetrieverAPI.JSON_SUCCESS_FIELD_NAME, false);	×
257	jsonData.add(DataRetrieverAPI.JSON_ERROR_MSG_FIELD_NAME, jsonMsg);	×
258
259	return jsonData.build().toString();	×
260
261	}
262
263
264	@GET
265	@AuthRequired
266	@Path(retrieveDataPartialAPIPath)
267	@Produces({"application/json"})
268	public String retrieveMyDataAsJsonString(
269	@Context ContainerRequestContext crc,
270	@QueryParam("dvobject_types") List<DvObject.DType> dvobject_types,
271	@QueryParam("published_states") List<String> published_states,
272	@QueryParam("selected_page") Integer selectedPage,
273	@QueryParam("mydata_search_term") String searchTerm,
274	@QueryParam("role_ids") List<Long> roleIds,
275	@QueryParam("userIdentifier") String userIdentifier,
276	@QueryParam("filter_validities") Boolean filterValidities,
277	@QueryParam("dataset_valid") List<Boolean> datasetValidities) {
278	boolean OTHER_USER = false;	×
279
NEW 280	String noMsgResultsFound = BundleUtil.getStringFromBundle("dataretrieverAPI.noMsgResultsFound");	×
281
282	if ((session.getUser() != null) && (session.getUser().isAuthenticated())) {	×
283	authUser = (AuthenticatedUser) session.getUser();	×
284	} else {
285	try {
286	authUser = getRequestAuthenticatedUserOrDie(crc);	×
287	} catch (WrappedResponse e) {	×
NEW 288	return this.getJSONErrorString(	×
NEW 289	BundleUtil.getStringFromBundle("dataretrieverAPI.authentication.required"),	×
NEW 290	BundleUtil.getStringFromBundle("dataretrieverAPI.authentication.required.opt")	×
291	);
UNCOV 292	}	×
293	}
294
295	// For superusers, the searchUser may differ from the authUser
296	AuthenticatedUser searchUser = null;	×
297	// If the user is a superuser, see if a userIdentifier has been specified and use that instead
298	if ((authUser.isSuperuser()) && (userIdentifier != null) && (!userIdentifier.isEmpty())) {	×
299	searchUser = getUserFromIdentifier(userIdentifier);	×
300	if (searchUser != null) {	×
301	authUser = searchUser;	×
302	OTHER_USER = true;	×
303	} else {
NEW 304	return this.getJSONErrorString(	×
NEW 305	BundleUtil.getStringFromBundle("dataretrieverAPI.user.not.found", Arrays.asList(userIdentifier)),	×
306	null);
307	}
308	}
309
310	roleList = dataverseRoleService.findAll();	×
311	rolePermissionHelper = new DataverseRolePermissionHelper(roleList);	×
312
313
314	List<DvObject.DType> dtypes;
315	if (dvobject_types != null){	×
316	dtypes = dvobject_types;	×
317	}else{
318	dtypes = MyDataFilterParams.defaultDvObjectTypes;	×
319	}
320	List<String> pub_states = null;	×
321	if (published_states != null){	×
322	pub_states = published_states;	×
323	}
324	List<Boolean> validities = null;	×
325	if (filterValidities != null && filterValidities){	×
326	validities = datasetValidities;	×
327	}
328
329	// ---------------------------------
330	// (1) Initialize filterParams and check for Errors
331	// ---------------------------------
332	DataverseRequest dataverseRequest = createDataverseRequest(authUser);	×
333
334
335	MyDataFilterParams filterParams = new MyDataFilterParams(dataverseRequest, dtypes, pub_states, roleIds, searchTerm, validities);	×
336	if (filterParams.hasError()){	×
337	return this.getJSONErrorString(filterParams.getErrorMessage(), filterParams.getErrorMessage());	×
338	}
339
340	// ---------------------------------
341	// (2) Initialize MyDataFinder and check for Errors
342	// ---------------------------------
343	myDataFinder = new MyDataFinder(rolePermissionHelper,	×
344	roleAssigneeService,
345	dvObjectServiceBean,
346	groupService);
UNCOV 347	this.myDataFinder.runFindDataSteps(filterParams);	×
348	if (myDataFinder.hasError()){	×
349	return this.getJSONErrorString(myDataFinder.getErrorMessage(), myDataFinder.getErrorMessage());	×
350	}
351
352	// ---------------------------------
353	// (3) Make Solr Query
354	// ---------------------------------
355	int paginationStart = 1;	×
356	if (selectedPage != null){	×
357	paginationStart = selectedPage;	×
358	}
359	int solrCardStart = (paginationStart - 1) * SearchConstants.NUM_SOLR_DOCS_TO_RETRIEVE;	×
360
361	// Default the searchUser to the authUser.
362	// The exception: for logged-in superusers, the searchUser may differ from the authUser
363	//
364	if (searchUser == null){	×
365	searchUser = authUser;	×
366	}
367
368	//msg("search with user: " + searchUser.getIdentifier());
369
370	List<String> filterQueries = this.myDataFinder.getSolrFilterQueries();	×
371	if (filterQueries==null){	×
372	logger.fine("No ids found for this search");	×
373	return this.getJSONErrorString(noMsgResultsFound, null);	×
374	}
375	//msgt("myDataFinder.getSolrFilterQueries(): " + myDataFinder.getSolrFilterQueries().toString());
376
377	//msg("Selected paginationStart: " + paginationStart);
378
379	try {
380	solrQueryResponse = searchService.search(	×
381	dataverseRequest,
382	null, // subtree, default it to Dataverse for now
383	filterParams.getSearchTerm(), //"*", //	×
384	filterQueries,//filterQueries,
385	//SearchFields.NAME_SORT, SortBy.ASCENDING,
386	SearchFields.RELEASE_OR_CREATE_DATE, SortBy.DESCENDING,
387	solrCardStart, //paginationStart,
388	true, // dataRelatedToMe
389	SearchConstants.NUM_SOLR_DOCS_TO_RETRIEVE //10 // SearchFields.NUM_SOLR_DOCS_TO_RETRIEVE
390	);
391
392	//msgt("getResultsStart: " + this.solrQueryResponse.getResultsStart());
393	//msgt("getNumResultsFound: " + this.solrQueryResponse.getNumResultsFound());
394	//msgt("getSolrSearchResults: " + this.solrQueryResponse.getSolrSearchResults().toString());
395	if (this.solrQueryResponse.getNumResultsFound()==0){	×
396	return this.getJSONErrorString(noMsgResultsFound, null);	×
397	}
398
399	} catch (SearchException ex) {	×
400	solrQueryResponse = null;	×
NEW 401	logger.severe("Solr SearchException: " + ex.getMessage());	×
402	}	×
403
NEW 404	if (solrQueryResponse == null) {	×
NEW 405	return this.getJSONErrorString(	×
NEW 406	BundleUtil.getStringFromBundle("dataretrieverAPI.solr.error"),	×
NEW 407	BundleUtil.getStringFromBundle("dataretrieverAPI.solr.error.opt")	×
408	);
409	}
410
411	// ---------------------------------
412	// (4) Build JSON document including:
413	// - Pager
414	// - Formatted solr docs
415	// - Num results found
416	// - Search term
417	// - DvObject counts
418	// ---------------------------------
419
420	// Initialize JSON response
421	JsonObjectBuilder jsonData = Json.createObjectBuilder();	×
422
423	Pager pager = new Pager(solrQueryResponse.getNumResultsFound().intValue(),	×
424	SearchConstants.NUM_SOLR_DOCS_TO_RETRIEVE,
425	paginationStart);
426
427	RoleTagRetriever roleTagRetriever = new RoleTagRetriever(this.rolePermissionHelper, this.roleAssigneeSvc, this.dvObjectServiceBean);	×
428	roleTagRetriever.loadRoles(dataverseRequest, solrQueryResponse);	×
429
430
431	jsonData.add(DataRetrieverAPI.JSON_SUCCESS_FIELD_NAME, true)	×
432	.add(DataRetrieverAPI.JSON_DATA_FIELD_NAME,	×
433	Json.createObjectBuilder()	×
434	.add("pagination", pager.asJsonObjectBuilderUsingCardTerms())	×
435	//.add(SearchConstants.SEARCH_API_ITEMS, this.formatSolrDocs(solrQueryResponse, filterParams, this.myDataFinder))
436	.add(SearchConstants.SEARCH_API_ITEMS, this.formatSolrDocs(solrQueryResponse, roleTagRetriever))	×
437	.add(SearchConstants.SEARCH_API_TOTAL_COUNT, solrQueryResponse.getNumResultsFound())	×
438	.add(SearchConstants.SEARCH_API_START, solrQueryResponse.getResultsStart())	×
439	.add("search_term", filterParams.getSearchTerm())	×
440	.add("dvobject_counts", this.getDvObjectTypeCounts(solrQueryResponse))	×
441	.add("pubstatus_counts", this.getPublicationStatusCounts(solrQueryResponse))	×
442	.add("selected_filters", this.myDataFinder.getSelectedFilterParamsAsJSON())	×
443	);
444
445	// ---------------------------------------------------------
446	// We're doing ~another~ solr query here
447	// NOTE! Do not reuse this.myDataFinder after this step!! It is being passed new filterParams
448	// ---------------------------------------------------------
449	//jsonData.add("total_dvobject_counts", getTotalCountsFromSolrAsJSON(searchUser, this.myDataFinder));
450
451
452	if (OTHER_USER){	×
453	jsonData.add("other_user", searchUser.getIdentifier());	×
454	}
455
456	return jsonData.build().toString();	×
457	}
458
459	private JsonObjectBuilder getDvObjectTypeCounts(SolrQueryResponse solrResponse) {
460
461	if (solrQueryResponse == null) {	×
462	logger.severe("DataRetrieverAPI.getDvObjectTypeCounts: solrQueryResponse should not be null");	×
463	return null;	×
464	}
465	return solrResponse.getDvObjectCountsAsJSON();	×
466	}
467
468	private JsonObjectBuilder getPublicationStatusCounts(SolrQueryResponse solrResponse) {
469
470	if (solrQueryResponse == null) {	×
471	logger.severe("DataRetrieverAPI.getDvObjectTypeCounts: solrQueryResponse should not be null");	×
472	return null;	×
473	}
474	return solrResponse.getPublicationStatusCountsAsJSON();	×
475	}
476
477	/**
478	* Using RoleTagRetriever to find role names for each card
479	* Trying to minimize extra queries
480	*
481	* @param solrResponse
482	* @param roleTagRetriever
483	* @return
484	*/
485	private JsonArrayBuilder formatSolrDocs(SolrQueryResponse solrResponse, RoleTagRetriever roleTagRetriever ){
486	if (solrResponse == null){	×
487	throw new NullPointerException("DataRetrieverAPI.formatSolrDocs: solrResponse should not be null");	×
488	}
489	if(roleTagRetriever==null){	×
490	throw new NullPointerException("DataRetrieverAPI.formatSolrDocs: roleTagRetriever should not be null");	×
491	}
492
493	JsonArrayBuilder jsonSolrDocsArrayBuilder = Json.createArrayBuilder();	×
494
495	JsonObjectBuilder myDataCardInfo;
496	JsonArrayBuilder rolesForCard;
497
498	for (SolrSearchResult doc : solrQueryResponse.getSolrSearchResults()){	×
499	// -------------------------------------------
500	// (a) Get core card data from solr
501	// -------------------------------------------
502
NEW 503	myDataCardInfo = doc.getJsonForMyData(isValid(doc));	×
504
NEW 505	if (doc.getEntity() != null && !doc.getEntity().isInstanceofDataFile()){	×
506	String parentAlias = dataverseService.getParentAliasString(doc);	×
507	myDataCardInfo.add("parent_alias",parentAlias);	×
508	}
509
510	// -------------------------------------------
511	// (b) Add role info
512	// -------------------------------------------
513	rolesForCard = roleTagRetriever.getRolesForCardAsJSON(doc.getEntityId());	×
514	if (rolesForCard!=null){	×
515	myDataCardInfo.add("user_roles", rolesForCard);	×
516	}
517
518	// -------------------------------------------
519	// (c) Add final MyData JSON to array
520	// -------------------------------------------
521	jsonSolrDocsArrayBuilder.add(myDataCardInfo);	×
522	}	×
523	return jsonSolrDocsArrayBuilder;	×
524
525	}
526
527	private boolean isValid(SolrSearchResult result) {
NEW 528	return result.isValid(x -> true);	×
529	}
530	}

IQSS / dataverse / #22693

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous