#22002

Committed 01 Apr 2024 07:56PM CUT coverage: 20.716% (+0.5%) from 20.173%

Build # #22002

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #10453 from IQSS/develop

Merge 6.2 into master

Run Details

704 of 2679 new or added lines in 152 files covered. (26.28%)

81 existing lines in 49 files now uncovered.

17160 of 82836 relevant lines covered (20.72%)

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/engine/command/impl/AbstractCreateDatasetCommand.java

package edu.harvard.iq.dataverse.engine.command.impl;

import edu.harvard.iq.dataverse.*;
import edu.harvard.iq.dataverse.authorization.Permission;
import edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser;
import edu.harvard.iq.dataverse.batch.util.LoggingUtil;
import edu.harvard.iq.dataverse.dataaccess.DataAccess;
import edu.harvard.iq.dataverse.datacapturemodule.DataCaptureModuleUtil;
import edu.harvard.iq.dataverse.datacapturemodule.ScriptRequestResponse;
import edu.harvard.iq.dataverse.engine.command.CommandContext;
import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
import edu.harvard.iq.dataverse.engine.command.RequiredPermissions;
import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
import edu.harvard.iq.dataverse.engine.command.exception.CommandExecutionException;
import edu.harvard.iq.dataverse.pidproviders.PidProvider;
import edu.harvard.iq.dataverse.pidproviders.PidUtil;
import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
import static edu.harvard.iq.dataverse.util.StringUtil.isEmpty;
import java.io.IOException;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.solr.client.solrj.SolrServerException;

/**;
 * An abstract base class for commands that creates {@link Dataset}s.
 *
 * @author michael
 */
@RequiredPermissions(Permission.AddDataset)
public abstract class AbstractCreateDatasetCommand extends AbstractDatasetCommand<Dataset> {
    
    private static final Logger logger = Logger.getLogger(AbstractCreateDatasetCommand.class.getCanonicalName());
    
    final protected boolean harvested;
    final protected boolean validate;
    
    public AbstractCreateDatasetCommand(Dataset theDataset, DataverseRequest aRequest) {
        this(theDataset, aRequest, false);
    }

    public AbstractCreateDatasetCommand(Dataset theDataset, DataverseRequest aRequest, boolean isHarvested) {
        super(aRequest, theDataset);
        harvested=isHarvested;
        this.validate = true;
    }

    public AbstractCreateDatasetCommand(Dataset theDataset, DataverseRequest aRequest, boolean isHarvested, boolean validate) {
        super(aRequest, theDataset);
        harvested=isHarvested;
        this.validate = validate;
    }
   
    protected void additionalParameterTests(CommandContext ctxt) throws CommandException {
        // base class - do nothing.
    }
    
    protected DatasetVersion getVersionToPersist( Dataset theDataset ) {
        return theDataset.getLatestVersion();
    }
    
    /**
     * Called after the dataset has been persisted, but before the persistence context
     * has been flushed. 
     * @param theDataset The em-managed dataset.
     * @param ctxt 
     * @throws edu.harvard.iq.dataverse.engine.command.exception.CommandException 
     */
    protected void postPersist( Dataset theDataset, CommandContext ctxt ) throws CommandException {
        // base class - default to nothing.
    }
    

    protected void postDBFlush( Dataset theDataset, CommandContext ctxt ) throws CommandException {
        // base class - default to nothing.
    }
    
    protected abstract void handlePid( Dataset theDataset, CommandContext ctxt ) throws CommandException ;
    
    @Override
    public Dataset execute(CommandContext ctxt) throws CommandException {
        
        additionalParameterTests(ctxt);
        
        Dataset theDataset = getDataset();
        PidProvider pidProvider = ctxt.dvObjects().getEffectivePidGenerator(theDataset);
        
        if ( isEmpty(theDataset.getIdentifier()) ) {
            pidProvider.generatePid(theDataset);
        }
        
        DatasetVersion dsv = getVersionToPersist(theDataset);
        // This re-uses the state setup logic of CreateDatasetVersionCommand, but
        // without persisting the new version, or altering its files. 
        new CreateDatasetVersionCommand(getRequest(), theDataset, dsv, validate).prepareDatasetAndVersion();
        
        if(!harvested) {
            checkSystemMetadataKeyIfNeeded(dsv, null);
        }
        
        theDataset.setCreator((AuthenticatedUser) getRequest().getUser());
        
        theDataset.setCreateDate(getTimestamp());

        theDataset.setModificationTime(getTimestamp());
        for (DataFile dataFile: theDataset.getFiles() ){
            dataFile.setCreator((AuthenticatedUser) getRequest().getUser());
            dataFile.setCreateDate(theDataset.getCreateDate());
        }
        
        if (theDataset.getProtocol()==null) {
            theDataset.setProtocol(pidProvider.getProtocol());
        }
        if (theDataset.getAuthority()==null) {
            theDataset.setAuthority(pidProvider.getAuthority());
        }
        if (theDataset.getStorageIdentifier() == null) {
                String driverId = theDataset.getEffectiveStorageDriverId();
                theDataset.setStorageIdentifier(driverId  + DataAccess.SEPARATOR + theDataset.getAuthorityForFileStorage() + "/" + theDataset.getIdentifierForFileStorage());
        }
        if (theDataset.getIdentifier()==null) {
            pidProvider.generatePid(theDataset);
        }
        
        // Attempt the registration if importing dataset through the API, or the app (but not harvest)
        handlePid(theDataset, ctxt);
        
        ctxt.em().persist(theDataset);
        
        postPersist(theDataset, ctxt);
        
        createDatasetUser(ctxt);
        
        theDataset = ctxt.em().merge(theDataset); // store last updates
        
        // DB updates - done.
        
        // Now we need the acutal dataset id, so we can start indexing.
        ctxt.em().flush();
        
        //Use for code that requires database ids
        postDBFlush(theDataset, ctxt);
        
        ctxt.index().asyncIndexDataset(theDataset, true);
                 
        return theDataset;
    }

    @Override
    public int hashCode() {
        return 97 + Objects.hashCode(getDataset());
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (!(obj instanceof AbstractCreateDatasetCommand)) {
            return false;
        }
        final AbstractCreateDatasetCommand other = (AbstractCreateDatasetCommand) obj;
        return Objects.equals(getDataset(), other.getDataset());
    }

    @Override
    public String toString() {
        return "[DatasetCreate dataset:" + getDataset().getId() + "]";
    }

}

1	package edu.harvard.iq.dataverse.engine.command.impl;
2
3	import edu.harvard.iq.dataverse.*;
4	import edu.harvard.iq.dataverse.authorization.Permission;
5	import edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser;
6	import edu.harvard.iq.dataverse.batch.util.LoggingUtil;
7	import edu.harvard.iq.dataverse.dataaccess.DataAccess;
8	import edu.harvard.iq.dataverse.datacapturemodule.DataCaptureModuleUtil;
9	import edu.harvard.iq.dataverse.datacapturemodule.ScriptRequestResponse;
10	import edu.harvard.iq.dataverse.engine.command.CommandContext;
11	import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
12	import edu.harvard.iq.dataverse.engine.command.RequiredPermissions;
13	import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
14	import edu.harvard.iq.dataverse.engine.command.exception.CommandExecutionException;
15	import edu.harvard.iq.dataverse.pidproviders.PidProvider;
16	import edu.harvard.iq.dataverse.pidproviders.PidUtil;
17	import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
18	import static edu.harvard.iq.dataverse.util.StringUtil.isEmpty;
19	import java.io.IOException;
20	import java.util.Objects;
21	import java.util.logging.Level;
22	import java.util.logging.Logger;
23	import org.apache.solr.client.solrj.SolrServerException;
24
25	/**;
26	* An abstract base class for commands that creates {@link Dataset}s.
27	*
28	* @author michael
29	*/
30	@RequiredPermissions(Permission.AddDataset)
31	public abstract class AbstractCreateDatasetCommand extends AbstractDatasetCommand<Dataset> {
32
33	private static final Logger logger = Logger.getLogger(AbstractCreateDatasetCommand.class.getCanonicalName());	×
34
35	final protected boolean harvested;
36	final protected boolean validate;
37
38	public AbstractCreateDatasetCommand(Dataset theDataset, DataverseRequest aRequest) {
39	this(theDataset, aRequest, false);	×
40	}	×
41
42	public AbstractCreateDatasetCommand(Dataset theDataset, DataverseRequest aRequest, boolean isHarvested) {
43	super(aRequest, theDataset);	×
44	harvested=isHarvested;	×
45	this.validate = true;	×
46	}	×
47
48	public AbstractCreateDatasetCommand(Dataset theDataset, DataverseRequest aRequest, boolean isHarvested, boolean validate) {
49	super(aRequest, theDataset);	×
50	harvested=isHarvested;	×
51	this.validate = validate;	×
52	}	×
53
54	protected void additionalParameterTests(CommandContext ctxt) throws CommandException {
55	// base class - do nothing.
56	}	×
57
58	protected DatasetVersion getVersionToPersist( Dataset theDataset ) {
59	return theDataset.getLatestVersion();	×
60	}
61
62	/**
63	* Called after the dataset has been persisted, but before the persistence context
64	* has been flushed.
65	* @param theDataset The em-managed dataset.
66	* @param ctxt
67	* @throws edu.harvard.iq.dataverse.engine.command.exception.CommandException
68	*/
69	protected void postPersist( Dataset theDataset, CommandContext ctxt ) throws CommandException {
70	// base class - default to nothing.
71	}	×
72
73
74	protected void postDBFlush( Dataset theDataset, CommandContext ctxt ) throws CommandException {
75	// base class - default to nothing.
76	}	×
77
78	protected abstract void handlePid( Dataset theDataset, CommandContext ctxt ) throws CommandException ;
79
80	@Override
81	public Dataset execute(CommandContext ctxt) throws CommandException {
82
83	additionalParameterTests(ctxt);	×
84
85	Dataset theDataset = getDataset();	×
NEW 86	PidProvider pidProvider = ctxt.dvObjects().getEffectivePidGenerator(theDataset);	×
87
88	if ( isEmpty(theDataset.getIdentifier()) ) {	×
NEW 89	pidProvider.generatePid(theDataset);	×
90	}
91
92	DatasetVersion dsv = getVersionToPersist(theDataset);	×
93	// This re-uses the state setup logic of CreateDatasetVersionCommand, but
94	// without persisting the new version, or altering its files.
95	new CreateDatasetVersionCommand(getRequest(), theDataset, dsv, validate).prepareDatasetAndVersion();	×
96
97	if(!harvested) {	×
98	checkSystemMetadataKeyIfNeeded(dsv, null);	×
99	}
100
101	theDataset.setCreator((AuthenticatedUser) getRequest().getUser());	×
102
103	theDataset.setCreateDate(getTimestamp());	×
104
105	theDataset.setModificationTime(getTimestamp());	×
106	for (DataFile dataFile: theDataset.getFiles() ){	×
107	dataFile.setCreator((AuthenticatedUser) getRequest().getUser());	×
108	dataFile.setCreateDate(theDataset.getCreateDate());	×
109	}	×
110
111	if (theDataset.getProtocol()==null) {	×
NEW 112	theDataset.setProtocol(pidProvider.getProtocol());	×
113	}
114	if (theDataset.getAuthority()==null) {	×
NEW 115	theDataset.setAuthority(pidProvider.getAuthority());	×
116	}
117	if (theDataset.getStorageIdentifier() == null) {	×
118	String driverId = theDataset.getEffectiveStorageDriverId();	×
119	theDataset.setStorageIdentifier(driverId + DataAccess.SEPARATOR + theDataset.getAuthorityForFileStorage() + "/" + theDataset.getIdentifierForFileStorage());	×
120	}
121	if (theDataset.getIdentifier()==null) {	×
NEW 122	pidProvider.generatePid(theDataset);	×
123	}
124
125	// Attempt the registration if importing dataset through the API, or the app (but not harvest)
126	handlePid(theDataset, ctxt);	×
127
128	ctxt.em().persist(theDataset);	×
129
130	postPersist(theDataset, ctxt);	×
131
132	createDatasetUser(ctxt);	×
133
134	theDataset = ctxt.em().merge(theDataset); // store last updates	×
135
136	// DB updates - done.
137
138	// Now we need the acutal dataset id, so we can start indexing.
139	ctxt.em().flush();	×
140
141	//Use for code that requires database ids
142	postDBFlush(theDataset, ctxt);	×
143
144	ctxt.index().asyncIndexDataset(theDataset, true);	×
145
146	return theDataset;	×
147	}
148
149	@Override
150	public int hashCode() {
151	return 97 + Objects.hashCode(getDataset());	×
152	}
153
154	@Override
155	public boolean equals(Object obj) {
156	if (obj == null) {	×
157	return false;	×
158	}
159	if (!(obj instanceof AbstractCreateDatasetCommand)) {	×
160	return false;	×
161	}
162	final AbstractCreateDatasetCommand other = (AbstractCreateDatasetCommand) obj;	×
163	return Objects.equals(getDataset(), other.getDataset());	×
164	}
165
166	@Override
167	public String toString() {
168	return "[DatasetCreate dataset:" + getDataset().getId() + "]";	×
169	}
170
171	}

IQSS / dataverse / #22002

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