Context Navigation

← Previous Changeset
Next Changeset →

Changeset 797

Timestamp:

01/23/09 15:17:10 (4 years ago)

Author:

anthony

Message:

improvements to some of the way bulk upload handles missing samples/subsamples
return back the column number and column data to the client (the display needs work)

Location:

trunk

Files:

: 11 modified

mpdb-client/src/edu/rpi/metpetdb/client/ui/bulk/upload/BulkUploadPanel.java (modified) (2 diffs)
mpdb-common/src/edu/rpi/metpetdb/client/model/bulk/upload/BulkUploadError.java (modified) (3 diffs)
mpdb-common/src/edu/rpi/metpetdb/client/model/bulk/upload/BulkUploadResult.java (modified) (5 diffs)
mpdb-common/src/edu/rpi/metpetdb/client/service/bulk/upload/BulkUploadService.java (modified) (2 diffs)
mpdb-server/src/edu/rpi/metpetdb/server/MpDbServlet.java (modified) (5 diffs)
mpdb-server/src/edu/rpi/metpetdb/server/bulk/upload/NewParser.java (modified) (3 diffs)
mpdb-server/src/edu/rpi/metpetdb/server/impl/UserServiceImpl.java (modified) (4 diffs)
mpdb-server/src/edu/rpi/metpetdb/server/impl/bulk/upload/BulkUploadChemicalAnalysesServiceImpl.java (modified) (2 diffs)
mpdb-server/src/edu/rpi/metpetdb/server/impl/bulk/upload/BulkUploadImagesServiceImpl.java (modified) (4 diffs)
mpdb-server/src/edu/rpi/metpetdb/server/impl/bulk/upload/BulkUploadSampleServiceImpl.java (modified) (3 diffs)
mpdb-server/src/edu/rpi/metpetdb/server/impl/bulk/upload/BulkUploadService.java (modified) (4 diffs)

Legend:

: Unmodified
: Added
: Removed

trunk/mpdb-client/src/edu/rpi/metpetdb/client/ui/bulk/upload/BulkUploadPanel.java

r794	r797
30	30
31	31	import edu.rpi.metpetdb.client.error.LoginRequiredException;
32		~~import edu.rpi.metpetdb.client.error.MpDbException;~~
33	32	import edu.rpi.metpetdb.client.locale.LocaleEntity;
34	33	import edu.rpi.metpetdb.client.locale.LocaleHandler;
…	…
445	444	final Iterator<BulkUploadError> itr = exceptions.iterator();
446	445	while(itr.hasNext()) {
447		text += "<span>" + itr.next().getException().format() + "</span> ";
	446	final BulkUploadError err = itr.next();
	447	text += "<span>Column:" + err.getColumn() + "</span>";
	448	text += "<span>Cell Data:" + err.getCellData() + "</span>";
	449	text += "<span>Error Message:" + err.getException().format() + "</span>";
448	450	}
449	451	return text;

trunk/mpdb-common/src/edu/rpi/metpetdb/client/model/bulk/upload/BulkUploadError.java

r741	r797
10	10	private int row;
11	11	private int column;
	12	private String cellData;
12	13
13	14	public BulkUploadError() {
…	…
15	16	}
16	17
17		public BulkUploadError(final int row, final int column, final MpDbException e) {
	18	public BulkUploadError(final int row, final int column, final MpDbException e, final String cellData) {
18	19	this.row = row;
19	20	this.column = column;
20	21	this.exception = e;
	22	this.cellData = cellData;
21	23	}
22	24
…	…
45	47	}
46	48
	49	public String getCellData() {
	50	return cellData;
	51	}
	52
	53	public void setCellData(String cellData) {
	54	this.cellData = cellData;
	55	}
47	56	}

trunk/mpdb-common/src/edu/rpi/metpetdb/client/model/bulk/upload/BulkUploadResult.java

r742	r797
1	1	package edu.rpi.metpetdb.client.model.bulk.upload;
2	2
	3	import java.sql.Date;
3	4	import java.util.ArrayList;
4	5	import java.util.HashMap;
…	…
12	13	public class BulkUploadResult implements IsSerializable {
13	14
	15	private Date timeTaken;
14	16	private Map<Integer, BulkUploadHeader> headers;
15	17	//maps row numbers to a list of exceptions
…	…
26	28
27	29	public void addError(final int rowNumber, final MpDbException e) {
28		addError(rowNumber, -1, e);
	30	addError(rowNumber, -1, "", e);
29	31	}
30	32
31		public void addError(final int rowNumber, final int colNumber, final MpDbException e) {
	33	public void addError(final int rowNumber, final int colNumber, final String cellData, final MpDbException e) {
32	34	final BulkUploadError buError = new BulkUploadError();
33	35	buError.setRow(rowNumber);
34	36	buError.setColumn(colNumber);
35	37	buError.setException(e);
	38	buError.setCellData(cellData);
36	39	if (!errors.containsKey(rowNumber))
37	40	errors.put(rowNumber, new ArrayList<BulkUploadError>());
…	…
40	43
41	44	public Map<Integer,BulkUploadHeader> getHeaders() {
	45	if (headers == null)
	46	headers = new HashMap<Integer, BulkUploadHeader>();
42	47	return headers;
43	48	}
…	…
60	65	}
61	66
	67	public Date getTimeTaken() {
	68	return timeTaken;
	69	}
	70
	71	public void setTimeTaken(Date timeTaken) {
	72	this.timeTaken = timeTaken;
	73	}
	74
62	75
63	76	}

trunk/mpdb-common/src/edu/rpi/metpetdb/client/service/bulk/upload/BulkUploadService.java

r741	r797
3	3	import com.google.gwt.user.client.rpc.RemoteService;
4	4
	5	import edu.rpi.metpetdb.client.error.DAOException;
5	6	import edu.rpi.metpetdb.client.error.InvalidFormatException;
6	7	import edu.rpi.metpetdb.client.error.LoginRequiredException;
…	…
10	11	public interface BulkUploadService extends RemoteService {
11	12	BulkUploadResult parser(final String fileOnServer, boolean save)
12		throws InvalidFormatException, LoginRequiredException;
	13	throws InvalidFormatException, LoginRequiredException, DAOException;
13	14	}

trunk/mpdb-server/src/edu/rpi/metpetdb/server/MpDbServlet.java

r796	r797
52	52	import edu.rpi.metpetdb.server.dao.impl.MineralDAO;
53	53	import edu.rpi.metpetdb.server.dao.impl.OxideDAO;
	54	import edu.rpi.metpetdb.server.dao.impl.UserDAO;
54	55	import edu.rpi.metpetdb.server.impl.ImageServiceImpl;
55	56	import edu.rpi.metpetdb.server.security.Action;
…	…
140	141	DataStore.initFactory();
141	142	doc = DataStore.getInstance().getDatabaseObjectConstraints();
	143	if (doc == null) {
	144	throw new RuntimeException("Unable to get constraints, check the tomct logs");
	145	}
142	146	oc = DataStore.getInstance().getObjectConstraints();
143	147
…	…
241	245	* invalid.
242	246	*/
243		protected int currentUser() throws LoginRequiredException {
	247	protected int currentUserId() throws LoginRequiredException {
244	248	if (autoLoginId != -1) {
245	249	System.out.println("using autologin id of " + autoLoginId);
…	…
269	273	}
270	274
	275	protected User currentUser() throws LoginRequiredException, DAOException {
	276	if (currentReq() != null)
	277	return currentReq().currentUser(currentUserId());
	278	else
	279	throw new LoginRequiredException();
	280	}
	281
271	282	/**
272	283	* Obtain a session for the current thread.
…	…
400	411	}
401	412
402		public SearchSample getLastSearchedSearchSample(){
403		return (SearchSample) this.getThreadLocalRequest().getSession().getAttribute("lastSearchSamp");
404		}
405
406		public void setLastSearchedSearchSample(final SearchSample searchSamp){
407		this.getThreadLocalRequest().getSession().setAttribute("lastSearchSamp", searchSamp);
408		}
409
410		public PaginationParameters getLastSearchPagination(){
411		return (PaginationParameters) this.getThreadLocalRequest().getSession().getAttribute("lastSearchPagination");
412		}
413
414		public void setLastSearchPagination(final PaginationParameters p){
415		this.getThreadLocalRequest().getSession().setAttribute("lastSearchPagination", p);
416		}
417
	413	public SearchSample getLastSearchedSearchSample() {
	414	return (SearchSample) this.getThreadLocalRequest().getSession()
	415	.getAttribute("lastSearchSamp");
	416	}
	417
	418	public void setLastSearchedSearchSample(final SearchSample searchSamp) {
	419	this.getThreadLocalRequest().getSession().setAttribute(
	420	"lastSearchSamp", searchSamp);
	421	}
	422
	423	public PaginationParameters getLastSearchPagination() {
	424	return (PaginationParameters) this.getThreadLocalRequest().getSession()
	425	.getAttribute("lastSearchPagination");
	426	}
	427
	428	public void setLastSearchPagination(final PaginationParameters p) {
	429	this.getThreadLocalRequest().getSession().setAttribute(
	430	"lastSearchPagination", p);
	431	}
	432
418	433	public static final class Req {
419	434	Session session;
420	435	Integer userId;
	436	User user;
421	437	public Action action;
422	438	public Collection<Principal> principals;
	439
	440	User currentUser(int userId) throws DAOException {
	441	if (user == null) {
	442	user = new User();
	443	user.setId(userId);
	444	user = new UserDAO(currentSession()).fill(user);
	445	}
	446	return user;
	447	}
423	448
424	449	Session currentSession() {

trunk/mpdb-server/src/edu/rpi/metpetdb/server/bulk/upload/NewParser.java

r787	r797
216	216	NewParser.oxides = oxides;
217	217	}
218
	218
219	219	public static void setImageTypes(final Collection<ImageType> imageTypes) {
220	220	NewParser.imageTypes = imageTypes;
…	…
297	297	parseDate(objectWithDate, data);
298	298	} catch (final ValidationException ve) {
299		errors
300		.put(rowindex,
301		new BulkUploadError(
302		rowindex + 1,
303		i + 1, ve));
	299	errors.put(rowindex,
	300	new BulkUploadError(
	301	rowindex + 1, i + 1,
	302	ve, data));
304	303	}
305	304	}
…	…
335	334	} catch (MpDbException e) {
336	335	errors.put(rowindex + 1, new BulkUploadError(rowindex + 1,
337		i + 1, e));
	336	i + 1, e, cell.toString()));
338	337	} catch (NumberFormatException e) {
339	338	// TODO maybe handle specially?
340	339	errors.put(rowindex + 1, new BulkUploadError(rowindex + 1,
341		i + 1, new GenericDAOException(e.getMessage())));
	340	i + 1, new GenericDAOException(e.getMessage()), cell
	341	.toString()));
342	342	} catch (Exception e) {
343	343	errors.put(rowindex + 1, new BulkUploadError(rowindex + 1,
344		i + 1, new GenericDAOException(e.getMessage())));
	344	i + 1, new GenericDAOException(e.getMessage()), cell
	345	.toString()));
345	346	}
346	347	}

trunk/mpdb-server/src/edu/rpi/metpetdb/server/impl/UserServiceImpl.java

r796	r797
100	100	try {
101	101	User u = new User();
102		u.setId(currentUser());
	102	u.setId(currentUserId());
103	103	u = (new UserDAO(this.currentSession())).fill(u);
104	104	r.user = (User) clone(u);
…	…
114	114	LoginRequiredException {
115	115	User u = new User();
116		u.setId(currentUser());
	116	u.setId(currentUserId());
117	117	u = (new UserDAO(this.currentSession())).fill(u);
118	118	return (u);
…	…
168	168	final UserDAO uDAO = new UserDAO(this.currentSession());
169	169	final User User = uwp.getUser();
170		if (User.getId() != currentUser())
	170	if (User.getId() != currentUserId())
171	171	throw new GenericDAOException("Administrators are not supported!");
172	172
…	…
202	202	LoginRequiredException {
203	203	User u = new User();
204		u.setId(currentUser());
	204	u.setId(currentUserId());
205	205	final UserDAO ud = new UserDAO(this.currentSession());
206	206	u = (ud).fill(u);

trunk/mpdb-server/src/edu/rpi/metpetdb/server/impl/bulk/upload/BulkUploadChemicalAnalysesServiceImpl.java

r775	r797
2	2
3	3	import java.io.FileInputStream;
4		import java.io.IOException;
	4	import java.io.FileNotFoundException;
5	5	import java.util.Collection;
6		~~import java.util.HashMap;~~
7		~~import java.util.HashSet;~~
8	6	import java.util.Iterator;
9	7	import java.util.Map;
10		~~import java.util.Set;~~
11	8
12		~~import org.hibernate.HibernateException;~~
13		~~import org.hibernate.exception.GenericJDBCException;~~
14
15		~~import edu.rpi.metpetdb.client.error.DAOException;~~
16		~~import edu.rpi.metpetdb.client.error.InvalidFormatException;~~
17	9	import edu.rpi.metpetdb.client.error.LoginRequiredException;
18	10	import edu.rpi.metpetdb.client.error.MpDbException;
19		~~import edu.rpi.metpetdb.client.error.ValidationException;~~
20		~~import edu.rpi.metpetdb.client.error.dao.GenericDAOException;~~
21	11	import edu.rpi.metpetdb.client.error.validation.PropertyRequiredException;
22	12	import edu.rpi.metpetdb.client.model.ChemicalAnalysis;
23	13	import edu.rpi.metpetdb.client.model.Sample;
24	14	import edu.rpi.metpetdb.client.model.Subsample;
25		~~import edu.rpi.metpetdb.client.model.User;~~
26		~~import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadError;~~
27	15	import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadResult;
28	16	import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadResultCount;
29	17	import edu.rpi.metpetdb.client.service.bulk.upload.BulkUploadChemicalAnalysesService;
30	18	import edu.rpi.metpetdb.server.MpDbServlet;
31		~~import edu.rpi.metpetdb.server.bulk.upload.AnalysisParser;~~
32	19	import edu.rpi.metpetdb.server.bulk.upload.NewAnalysisParser;
33	20	import edu.rpi.metpetdb.server.dao.impl.ChemicalAnalysisDAO;
34	21	import edu.rpi.metpetdb.server.dao.impl.SampleDAO;
35	22	import edu.rpi.metpetdb.server.dao.impl.SubsampleDAO;
36		~~import edu.rpi.metpetdb.server.dao.impl.UserDAO;~~
37	23
38	24	public class BulkUploadChemicalAnalysesServiceImpl extends BulkUploadService
…	…
41	27	public static final long serialVersionUID = 1L;
42	28
43		public BulkUploadResult parser(String fileOnServer, boolean save)
44		throws InvalidFormatException, LoginRequiredException {
45		final BulkUploadResult results = new BulkUploadResult();
46		try {
47		if (save) {
48		updateFile(fileOnServer);
	29	@Override
	30	public void parserImpl(String fileOnServer, boolean save,
	31	BulkUploadResult results, SampleDAO sampleDao, SubsampleDAO ssDao,
	32	final Map<String, Collection<String>> subsampleNames,
	33	final Map<String, Sample> samples,
	34	final Map<String, Subsample> subsamples)
	35	throws FileNotFoundException, MpDbException, LoginRequiredException {
	36	final NewAnalysisParser ap = new NewAnalysisParser(new FileInputStream(
	37	MpDbServlet.getFileUploadPath() + fileOnServer));
	38	ap.parse();
	39	final Map<Integer, ChemicalAnalysis> analyses = ap
	40	.getChemicalAnalyses();
	41	// Handle any existing errors found
	42	addErrors(ap, results);
	43	final BulkUploadResultCount caResultCount = new BulkUploadResultCount();
	44	final BulkUploadResultCount ssResultCount = new BulkUploadResultCount();
	45	final Iterator<Integer> rows = analyses.keySet().iterator();
	46	final ChemicalAnalysisDAO caDao = new ChemicalAnalysisDAO(
	47	currentSession());
	48	while (rows.hasNext()) {
	49	int row = rows.next();
	50	final ChemicalAnalysis ca = analyses.get(row);
	51	initObject(ca);
	52	try {
	53	// see if our subsample exists
	54	if (ca.getSubsample() == null) {
	55	results.addError(row, new PropertyRequiredException(
	56	"Subsample"));
	57	continue;
	58	}
	59	// see if our sample exists
	60	if (ca.getSubsample().getSample() == null) {
	61	results.addError(row, new PropertyRequiredException(
	62	"Sample"));
	63	continue;
	64	}
	65	Sample s = ca.getSubsample().getSample();
	66	checkForSample(s, samples, sampleDao, results, subsampleNames,
	67	row);
	68	Subsample ss = (ca.getSubsample());
	69	ss.setSample(s);
	70	if (ss != null && s != null) {
	71	// if we don't have the name stored already we need
	72	// to load the subsample
	73	ca.setSubsample(checkForSubsample(s, ss, samples, ssDao,
	74	results, subsampleNames, row, subsamples,
	75	ssResultCount, save));
	76	} else {
	77	// Every Image needs a subsample so add an error
	78	results.addError(row, new PropertyRequiredException(
	79	"Subsample"));
	80	}
	81	doc.validate(ca);
	82	if (caDao.isNew(ca))
	83	caResultCount.incrementFresh();
	84	else
	85	caResultCount.incrementOld();
	86	if (save)
	87	caDao.save(ca);
	88	} catch (Exception e) {
	89	results.addError(row, getNiceException(e));
	90	caResultCount.incrementInvalid();
49	91	}
50		final NewAnalysisParser ap = new NewAnalysisParser(
51		new FileInputStream(MpDbServlet.getFileUploadPath()
52		+ fileOnServer));
53		ap.parse();
54		final Map<Integer, ChemicalAnalysis> analyses = ap
55		.getChemicalAnalyses();
56		// Handle any existing errors found
57		final Map<Integer, BulkUploadError> existingErrors = ap.getErrors();
58		final Set<Integer> keys = existingErrors.keySet();
59		final Iterator<Integer> itr = keys.iterator();
60		while (itr.hasNext()) {
61		final Integer i = itr.next();
62		results.addError(i.intValue(), existingErrors.get(i)
63		.getException());
64		}
65
66		// Keeps track of existing/new subsample names for each sample
67		final Map<String, Collection<String>> subsampleNames = new HashMap<String, Collection<String>>();
68		// maps a sample alias to an actual sample
69		final Map<String, Sample> samples = new HashMap<String, Sample>();
70		// maps a sample alias + subsample name to an actual subsample
71		final Map<String, Subsample> subsamples = new HashMap<String, Subsample>();
72		final BulkUploadResultCount caResultCount = new BulkUploadResultCount();
73		final BulkUploadResultCount ssResultCount = new BulkUploadResultCount();
74		final ChemicalAnalysisDAO dao = new ChemicalAnalysisDAO(this
75		.currentSession());
76		final SubsampleDAO ssDAO = new SubsampleDAO(this.currentSession());
77		final SampleDAO sDAO = new SampleDAO(this.currentSession());
78		User user = new User();
79		user.setId(currentUser());
80		user = new UserDAO(currentSession()).fill(user);
81		final Iterator<Integer> rows = analyses.keySet().iterator();
82		while (rows.hasNext()) {
83		int row = rows.next();
84		final ChemicalAnalysis ca = analyses.get(row);
85		try {
86		// see if our subsample exists
87		if (ca.getSubsample() == null) {
88		results.addError(row, new PropertyRequiredException(
89		"Subsample"));
90		continue;
91		}
92		// see if our sample exists
93		if (ca.getSubsample().getSample() == null) {
94		results.addError(row, new PropertyRequiredException(
95		"Sample"));
96		continue;
97		}
98		Sample s = ca.getSubsample().getSample();
99		s.setOwner(user);
100		ca.getSubsample().setOwner(user);
101		ca.setOwner(user);
102		ca.setPublicData(false);
103		ca.getSubsample().setPublicData(false);
104		try {
105		// if we don't have this sample already loaded check
106		// for it in the database
107		if (!samples.containsKey(s.getAlias())) {
108		s = sDAO.fill(s);
109		samples.put(s.getAlias(), s);
110		subsampleNames.put(s.getAlias(),
111		new HashSet<String>());
112		} else {
113		s = samples.get(s.getAlias());
114		}
115		} catch (DAOException e) {
116		// There is no sample we have to add an error
117		// Every Image needs a sample so add an error
118		results.addError(row, new PropertyRequiredException(
119		"Sample"));
120		results.addError(row, e);
121		continue;
122		}
123		Subsample ss = (ca.getSubsample());
124		ss.setSample(s);
125		if (ss != null && s != null) {
126		// if we don't have the name stored already we need
127		// to load the subsample
128		if (!subsampleNames.get(s.getAlias()).contains(
129		ss.getName())) {
130		try {
131		doc.validate(ss);
132		ss = ssDAO.fill(ss);
133		subsamples.put(s.getAlias() + ss.getName(), ss);
134		ca.setSubsample(ss);
135		ssResultCount.incrementOld();
136		} catch (DAOException e) {
137		// Means it is new because we could not find
138		// it
139		ssResultCount.incrementFresh();
140		if (save) {
141		try {
142		ss = ssDAO.save(ss);
143		} catch (DAOException e1) {
144		results.addError(row, e1);
145		}
146		subsamples.put(s.getAlias() + ss.getName(),
147		ss);
148		ca.setSubsample(ss);
149		}
150		}
151		subsampleNames.get(s.getAlias()).add(
152		ca.getSubsample().getName());
153		} else {
154		ca.setSubsample(subsamples.get(s.getAlias()
155		+ ss.getName()));
156		}
157		} else {
158		// Every Image needs a subsample so add an error
159		results.addError(row, new PropertyRequiredException(
160		"Subsample"));
161		}
162		doc.validate(ca);
163		if (dao.isNew(ca))
164		caResultCount.incrementFresh();
165		else
166		caResultCount.incrementOld();
167		if (save) {
168		try {
169		dao.save(ca);
170		} catch (MpDbException e) {
171		results.addError(row, e);
172		} catch (HibernateException e) {
173		results.addError(row, handleHibernateException(e));
174		}
175		}
176		} catch (ValidationException e) {
177		results.addError(row, e);
178		caResultCount.incrementInvalid();
179		} catch (HibernateException e) {
180		if (e instanceof GenericJDBCException) {
181		if (((GenericJDBCException)e).getSQLException().getSQLState().equals("25P02")) {
182		results.addError(row, new GenericDAOException("Bulk Upload stopped due to fatal error"));
183		}
184		} else {
185		results.addError(row, handleHibernateException(e));
186		}
187		}
188		++row;
189		}
190		results.addResultCount("Chemical Analysis", caResultCount);
191		results.addResultCount("Subsamples", ssResultCount);
192		results.setHeaders(ap.getHeaders());
193		if (save && results.getErrors().isEmpty()) {
194		try {
195		commit();
196		} catch (DAOException e) {
197		results.addError(0, e);
198		}
199		}
200		} catch (MpDbException e) {
201		results.addError(-1, e);
202		} catch (final Exception e) {
203		results.addError(-1, new GenericDAOException(e.getMessage()));
	92	++row;
204	93	}
205		return results;
	94	results.addResultCount("Chemical Analysis", caResultCount);
	95	results.addResultCount("Subsamples", ssResultCount);
	96	results.setHeaders(ap.getHeaders());
206	97	}
207	98	}

trunk/mpdb-server/src/edu/rpi/metpetdb/server/impl/bulk/upload/BulkUploadImagesServiceImpl.java

r787	r797
4	4	import java.io.File;
5	5	import java.io.FileInputStream;
	6	import java.io.FileNotFoundException;
6	7	import java.io.IOException;
7	8	import java.io.InputStream;
8	9	import java.util.ArrayList;
9	10	import java.util.Collection;
10		~~import java.util.HashMap;~~
11		~~import java.util.HashSet;~~
12	11	import java.util.Iterator;
13	12	import java.util.Map;
14		~~import java.util.Set;~~
15	13	import java.util.zip.ZipEntry;
16	14	import java.util.zip.ZipFile;
…	…
20	18
21	19	import edu.rpi.metpetdb.client.error.DAOException;
22		~~import edu.rpi.metpetdb.client.error.InvalidFormatException;~~
23	20	import edu.rpi.metpetdb.client.error.LoginRequiredException;
24	21	import edu.rpi.metpetdb.client.error.MpDbException;
…	…
32	29	import edu.rpi.metpetdb.client.model.Sample;
33	30	import edu.rpi.metpetdb.client.model.Subsample;
34		~~import edu.rpi.metpetdb.client.model.User;~~
35	31	import edu.rpi.metpetdb.client.model.XrayImage;
36		~~import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadError;~~
37	32	import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadResult;
38	33	import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadResultCount;
…	…
107	102	}
108	103
109		public BulkUploadResult parser(String fileOnServer, boolean save)
110		throws InvalidFormatException, LoginRequiredException {
111		final BulkUploadResult results = new BulkUploadResult();
	104	@Override
	105	public void parserImpl(String fileOnServer, boolean save,
	106	BulkUploadResult results, SampleDAO sampleDao, SubsampleDAO ssDao,
	107	Map<String, Collection<String>> subsampleNames,
	108	Map<String, Sample> samples, Map<String, Subsample> subsamples)
	109	throws FileNotFoundException, MpDbException, LoginRequiredException {
112	110	final BulkUploadResultCount ssResultCount = new BulkUploadResultCount();
113	111	final BulkUploadResultCount imgResultCount = new BulkUploadResultCount();
	112	// Find the Excel Spreadsheet
	113	FileInputStream is = new FileInputStream(MpDbServlet
	114	.getFileUploadPath()
	115	+ fileOnServer);
	116	ZipEntry spreadsheet;
114	117	try {
115		if (save) {
116		updateFile(fileOnServer);
117		}
118		// Find the Excel Spreadsheet
119		FileInputStream is = new FileInputStream(MpDbServlet
120		.getFileUploadPath()
121		+ fileOnServer);
122		ZipEntry spreadsheet = getSpreadsheetName(is);
123		if (spreadsheet == null)
124		throw new IllegalStateException("No Excel Spreasheet found");
125		String spreadsheetPrefix = (new File(spreadsheet.getName()))
126		.getParent();
127		if (spreadsheetPrefix == null)
128		spreadsheetPrefix = "";
129		else
130		spreadsheetPrefix += File.separator;
131
132		ZipFile zp = new ZipFile(MpDbServlet.getFileUploadPath()
133		+ fileOnServer);
134		final NewImageParser ip = new NewImageParser(zp
135		.getInputStream(spreadsheet));
136		ip.parse();
137		results.setHeaders(ip.getHeaders());
138		final Map<Integer, BulkUploadImage> images = ip
139		.getBulkUploadImages();
140		User u = new User();
141		u.setId(currentUser());
142		// Keeps track of existing/new subsample names for each sample
143		final Map<String, Collection<String>> subsampleNames = new HashMap<String, Collection<String>>();
144		// maps a sample alias to an actual sample
145		final Map<String, Sample> samples = new HashMap<String, Sample>();
146		// maps a sample alias + subsample name to an actual subsample
147		final Map<String, Subsample> subsamples = new HashMap<String, Subsample>();
148		final SubsampleDAO ssDAO = new SubsampleDAO(this.currentSession());
149		final SampleDAO sDAO = new SampleDAO(this.currentSession());
150		final ImageDAO dao = new ImageDAO(this.currentSession());
151		final Iterator<Integer> imgRows = images.keySet().iterator();
152		// Handle any existing errors found
153		final Map<Integer, BulkUploadError> existingErrors = ip.getErrors();
154		final Set<Integer> keys = existingErrors.keySet();
155		final Iterator<Integer> itr = keys.iterator();
156		while (itr.hasNext()) {
157		final Integer i = itr.next();
158		results.addError(i.intValue(), existingErrors.get(i)
159		.getException());
160		}
161
162		while (imgRows.hasNext()) {
163		final int row = imgRows.next();
164		final Image img = images.get(row).getImage();
165		// Confirm the filename is in the zip
166		if (zp.getEntry(spreadsheetPrefix + img.getFilename()) == null) {
167		results.addError(row, new InvalidImageException(
168		spreadsheetPrefix + img.getFilename()));
169		} else {
170		try {
171		// see if our sample exists
172		if (img.getSample() == null
173		&& img.getSubsample() == null) {
174		// Image needs a sample or a subsample to continue
	118	spreadsheet = getSpreadsheetName(is);
	119	} catch (IOException ioe) {
	120	throw new GenericDAOException(ioe.getMessage());
	121	}
	122	if (spreadsheet == null)
	123	throw new IllegalStateException("No Excel Spreasheet found");
	124	String spreadsheetPrefix = (new File(spreadsheet.getName()))
	125	.getParent();
	126	if (spreadsheetPrefix == null)
	127	spreadsheetPrefix = "";
	128	else
	129	spreadsheetPrefix += File.separator;
	130
	131	ZipFile zp;
	132	NewImageParser ip;
	133	try {
	134	zp = new ZipFile(MpDbServlet.getFileUploadPath() + fileOnServer);
	135	ip = new NewImageParser(zp.getInputStream(spreadsheet));
	136	} catch (IOException ioe) {
	137	throw new GenericDAOException(ioe.getMessage());
	138	}
	139
	140	ip.parse();
	141	results.setHeaders(ip.getHeaders());
	142	final Map<Integer, BulkUploadImage> images = ip.getBulkUploadImages();
	143	final Iterator<Integer> imgRows = images.keySet().iterator();
	144	// Handle any existing errors found
	145	addErrors(ip, results);
	146	final ImageDAO imgDao = new ImageDAO(currentSession());
	147	final XrayImageDAO xrayDao = new XrayImageDAO(currentSession());
	148	while (imgRows.hasNext()) {
	149	final int row = imgRows.next();
	150	final Image img = images.get(row).getImage();
	151	initObject(img);
	152	// Confirm the filename is in the zip
	153	if (zp.getEntry(spreadsheetPrefix + img.getFilename()) == null) {
	154	results.addError(row, new InvalidImageException(
	155	spreadsheetPrefix + img.getFilename()));
	156	} else {
	157	try {
	158	// see if our sample exists
	159	if (img.getSample() == null && img.getSubsample() == null) {
	160	// Image needs a sample or a subsample to continue
	161	results.addError(row, new PropertyRequiredException(
	162	"Sample or Subsample"));
	163	continue;
	164	}
	165	Sample s = img.getSample();
	166	if (!checkForSample(s, samples, sampleDao, results,
	167	subsampleNames, row))
	168	continue;
	169	if (img.getSample() != null && img.getSubsample() == null) {
	170	// we are adding a sample image
	171	} else {
	172	// we are adding an image to a subsample
	173	Subsample ss = (img.getSubsample());
	174	ss.setSample(s);
	175	img.setSample(null);
	176	if (ss != null) {
	177	// if we don't have the name stored already we
	178	// need
	179	// to load the subsample
	180	img.setSubsample(checkForSubsample(s, ss, samples,
	181	ssDao, results, subsampleNames, row,
	182	subsamples, ssResultCount, save));
	183	} else {
	184	// Every Image needs a subsample so add an error
175	185	results.addError(row,
176		new PropertyRequiredException(
177		"Sample or Subsample"));
178		continue;
	186	new PropertyRequiredException("Subsample"));
179	187	}
180		Sample s = img.getSample();
181		s.setOwner(u);
182		try {
183		// if we don't have this sample already loaded
184		// check
185		// for it in the database
186		if (!samples.containsKey(s.getAlias())) {
187		s = sDAO.fill(s);
188		samples.put(s.getAlias(), s);
189		subsampleNames.put(s.getAlias(),
190		new HashSet<String>());
191		} else {
192		s = samples.get(s.getAlias());
193		}
194		} catch (DAOException e) {
195		// There is no sample we have to add an error
196		// Every Image needs a sample so add an error
197		results.addError(row,
198		new PropertyRequiredException("Sample"));
199		continue;
	188	}
	189	doc.validate(img);
	190	if (imgDao.isNew(img))
	191	imgResultCount.incrementFresh();
	192	else
	193	imgResultCount.incrementOld();
	194	if (save) {
	195	setRealImage(zp, img, spreadsheetPrefix);
	196	if (img instanceof XrayImage) {
	197	xrayDao.save((XrayImage) img);
	198	} else {
	199	imgDao.save(img);
200	200	}
201		~~if (img.getSample() != null~~
202		~~&& img.getSubsample() == null) {~~
203		~~// we are adding a sample image~~
204		~~img.setSubsample(null); // ignore the subsample if~~
205		~~// they specified one~~
206		~~} else {~~
207		~~// we are adding an image to a subsample~~
208		~~img.getSubsample().setSample(img.getSample());~~
209		~~img.setSample(null);~~
210		~~img.getSubsample().setOwner(u);~~
211		~~img.getSubsample().setPublicData(false);~~
212		~~Subsample ss = (img.getSubsample());~~
213		~~if (ss != null) {~~
214		~~// if we don't have the name stored already we~~
215		~~// need~~
216		~~// to load the subsample~~
217		~~if (!subsampleNames.get(~~
218		~~ss.getSample().getAlias()).contains(~~
219		~~ss.getName())) {~~
220		~~try {~~
221		~~doc.validate(ss);~~
222		~~ss = ssDAO.fill(ss);~~
223		~~subsamples.put(ss.getSample()~~
224		~~.getAlias()~~
225		~~+ ss.getName(), ss);~~
226		~~img.setSubsample(ss);~~
227		~~ssResultCount.incrementOld();~~
228		~~} catch (DAOException e) {~~
229		~~// Means it is new because we could not~~
230		~~// find~~
231		~~// it~~
232		~~ssResultCount.incrementFresh();~~
233		~~if (save) {~~
234		~~try {~~
235		~~ss = ssDAO.save(ss);~~
236		~~} catch (DAOException e1) {~~
237		~~results.addError(row, e1);~~
238		}
239		~~subsamples.put(ss.getSample()~~
240		~~.getAlias()~~
241		~~+ ss.getName(), ss);~~
242		~~img.setSubsample(ss);~~
243		}
244		}
245		~~subsampleNames.get(~~
246		~~ss.getSample().getAlias()).add(~~
247		~~ss.getName());~~
248		~~} else {~~
249		~~img.setSubsample(subsamples.get(ss~~
250		~~.getSample().getAlias()~~
251		~~+ ss.getName()));~~
252		}
253		~~} else {~~
254		~~// Every Image needs a subsample so add an error~~
255		~~results.addError(row,~~
256		~~new PropertyRequiredException(~~
257		~~"Subsample"));~~
258		}
259		}
260
261		~~doc.validate(img);~~
262		~~if (dao.isNew(img))~~
263		~~imgResultCount.incrementFresh();~~
264		~~else~~
265		~~imgResultCount.incrementOld();~~
266		~~if (save) {~~
267		~~setRealImage(zp, img, spreadsheetPrefix);~~
268		~~try {~~
269		~~if (img instanceof XrayImage) {~~
270		~~(new XrayImageDAO(this.currentSession()))~~
271		~~.save((XrayImage) img);~~
272		~~} else {~~
273		~~(new ImageDAO(this.currentSession()))~~
274		~~.save(img);~~
275		}
276		~~} catch (DAOException e1) {~~
277		~~results.addError(row, e1);~~
278		}
279		}
280		~~} catch (ValidationException e) {~~
281		~~results.addError(row, e);~~
282		~~imgResultCount.incrementInvalid();~~
283	201	}
	202	} catch (Exception e) {
	203	results.addError(row, getNiceException(e));
	204	imgResultCount.incrementInvalid();
284	205	}
285	206	}
286
287		final Iterator<Integer> iogRows = images.keySet().iterator();
288		while (iogRows.hasNext()) {
289		final int row = iogRows.next();
290		final ImageOnGrid iog = images.get(row).getImageOnGrid();
291		Image img = iog.getImage();
292		// Confirm the filename is in the zip
293		if (zp.getEntry(spreadsheetPrefix + img.getFilename()) == null) {
294		results.addError(row, new InvalidImageException(
295		spreadsheetPrefix + img.getFilename()));
	207	}
	208
	209	final Iterator<Integer> iogRows = images.keySet().iterator();
	210	while (iogRows.hasNext()) {
	211	final int row = iogRows.next();
	212	final ImageOnGrid iog = images.get(row).getImageOnGrid();
	213	Image img = iog.getImage();
	214	// Confirm the filename is in the zip
	215	if (zp.getEntry(spreadsheetPrefix + img.getFilename()) == null) {
	216	results.addError(row, new InvalidImageException(
	217	spreadsheetPrefix + img.getFilename()));
	218	}
	219	try {
	220	doc.validate(img);
	221	if (save) {
	222	setRealImage(zp, iog.getImage(), spreadsheetPrefix);
	223
	224	// Set image information for the Grid Copy
	225	iog.setGchecksum(iog.getImage().getChecksum());
	226	iog.setGchecksum64x64(iog.getImage().getChecksum64x64());
	227	iog.setGchecksumHalf(iog.getImage().getChecksumHalf());
	228	iog.setGheight(iog.getImage().getHeight());
	229	iog.setGwidth(iog.getImage().getWidth());
	230	saveIncompleteImageOnGrid(iog);
296	231	}
297		try {
298		doc.validate(img);
299		if (save) {
300		setRealImage(zp, iog.getImage(), spreadsheetPrefix);
301
302		// Set image information for the Grid Copy
303		iog.setGchecksum(iog.getImage().getChecksum());
304		iog
305		.setGchecksum64x64(iog.getImage()
306		.getChecksum64x64());
307		iog.setGchecksumHalf(iog.getImage().getChecksumHalf());
308		iog.setGheight(iog.getImage().getHeight());
309		iog.setGwidth(iog.getImage().getWidth());
310		try {
311		saveIncompleteImageOnGrid(iog);
312		} catch (MpDbException e) {
313		results.addError(0, e);
314		}
315
316		}
317		} catch (ValidationException e) {
318		results.addError(row, e);
319		}
320		}
321
322		if (save && results.getErrors().isEmpty()) {
323		try {
324		commit();
325		} catch (DAOException e1) {
326		results.addError(0, e1);
327		}
328		}
329		} catch (MpDbException e) {
330		results.addError(-1, e);
331		} catch (Exception e) {
332		results.addError(-1, new GenericDAOException(e.getMessage()));
333		e.printStackTrace();
	232	} catch (Exception e) {
	233	results.addError(row, getNiceException(e));
	234	}
334	235	}
335	236	results.addResultCount("Subsamples", ssResultCount);
336	237	results.addResultCount("Images", imgResultCount);
337		~~return results;~~
338		}
	238	}
	239
339	240	protected ImageOnGrid saveIncompleteImageOnGrid(ImageOnGrid iog)
340	241	throws ValidationException, LoginRequiredException, DAOException {

trunk/mpdb-server/src/edu/rpi/metpetdb/server/impl/bulk/upload/BulkUploadSampleServiceImpl.java

r780	r797
2	2
3	3	import java.io.FileInputStream;
4		import java.io.IOException;
	4	import java.io.FileNotFoundException;
	5	import java.util.Collection;
5	6	import java.util.Iterator;
6	7	import java.util.Map;
7		~~import java.util.Set;~~
8	8
9		~~import org.hibernate.HibernateException;~~
10
11		~~import edu.rpi.metpetdb.client.error.DAOException;~~
12		~~import edu.rpi.metpetdb.client.error.InvalidFormatException;~~
13	9	import edu.rpi.metpetdb.client.error.LoginRequiredException;
14	10	import edu.rpi.metpetdb.client.error.MpDbException;
15		~~import edu.rpi.metpetdb.client.error.dao.GenericDAOException;~~
16	11	import edu.rpi.metpetdb.client.model.Sample;
17		import edu.rpi.metpetdb.client.model.User;
18		import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadError;
	12	import edu.rpi.metpetdb.client.model.Subsample;
19	13	import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadResult;
20	14	import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadResultCount;
…	…
23	17	import edu.rpi.metpetdb.server.bulk.upload.NewSampleParser;
24	18	import edu.rpi.metpetdb.server.dao.impl.SampleDAO;
25		import edu.rpi.metpetdb.server.dao.impl.~~User~~DAO;
	19	import edu.rpi.metpetdb.server.dao.impl.SubsampleDAO;
26	20
27	21	public class BulkUploadSampleServiceImpl extends BulkUploadService implements
…	…
29	23	private static final long serialVersionUID = 1L;
30	24
31		public BulkUploadResult parser(String fileOnServer, boolean save)
32		throws InvalidFormatException, LoginRequiredException {
33		final BulkUploadResult results = new BulkUploadResult();
34		try {
35		if (save) {
36		updateFile(fileOnServer);
	25	@Override
	26	public void parserImpl(String fileOnServer, boolean save,
	27	BulkUploadResult results, SampleDAO sampleDao, SubsampleDAO ssDao,
	28	final Map<String, Collection<String>> subsampleNames,
	29	final Map<String, Sample> cachedSamples,
	30	final Map<String, Subsample> subsamples)
	31	throws FileNotFoundException, MpDbException, LoginRequiredException {
	32	final NewSampleParser sp = new NewSampleParser(new FileInputStream(
	33	MpDbServlet.getFileUploadPath() + fileOnServer));
	34	sp.parse();
	35	results.setHeaders(sp.getHeaders());
	36	final Map<Integer, Sample> samples = sp.getSamples();
	37	addErrors(sp, results);
	38	final BulkUploadResultCount resultCount = new BulkUploadResultCount();
	39	final Iterator<Integer> rows = samples.keySet().iterator();
	40	while (rows.hasNext()) {
	41	final int row = rows.next();
	42	final Sample s = samples.get(row);
	43	initObject(s);
	44	try {
	45	if (sampleDao.isNew(s))
	46	resultCount.incrementFresh();
	47	else
	48	resultCount.incrementOld();
	49	if (save)
	50	sampleDao.save(s);
	51	} catch (Exception e) {
	52	resultCount.incrementInvalid();
	53	results.addError(row, getNiceException(e, s));
37	54	}
38		~~final NewSampleParser sp = new NewSampleParser(new FileInputStream(~~
39		~~MpDbServlet.getFileUploadPath() + fileOnServer));~~
40		~~sp.parse();~~
41		~~final Map<Integer, Sample> samples = sp.getSamples();~~
42		~~final SampleDAO dao = new SampleDAO(this.currentSession());~~
43		~~final Map<Integer, BulkUploadError> existingErrors = sp~~
44		~~.getErrors();~~
45		~~final Set<Integer> keys = existingErrors.keySet();~~
46		~~final Iterator<Integer> itr = keys.iterator();~~
47		~~while (itr.hasNext()) {~~
48		~~final Integer i = itr.next();~~
49		~~results.addError(i.intValue(), existingErrors.get(i).getException());~~
50		}
51		~~User user = new User();~~
52		~~user.setId(currentUser());~~
53		~~user = new UserDAO(currentSession()).fill(user);~~
54		~~final BulkUploadResultCount resultCount = new BulkUploadResultCount();~~
55		~~final Iterator<Integer> rows = samples.keySet().iterator();~~
56		~~while(rows.hasNext()) {~~
57		~~final int row = rows.next();~~
58		~~final Sample s = samples.get(row);~~
59		~~s.setOwner(user);~~
60		~~s.setPublicData(false);~~
61		~~try {~~
62		~~if (dao.isNew(s))~~
63		~~resultCount.incrementFresh();~~
64		~~else~~
65		~~resultCount.incrementOld();~~
66		~~} catch (HibernateException e) {~~
67		~~resultCount.incrementInvalid();~~
68		~~results.addError(row, handleHibernateException(e, s));~~
69		}
70		~~if (save) {~~
71		~~try {~~
72		~~dao.save(s);~~
73		~~} catch (HibernateException he) {~~
74		~~results.addError(row, handleHibernateException(he, s));~~
75		~~} catch (DAOException e) {~~
76		~~results.addError(row, e);~~
77		}
78		}
79		}
80		~~results.addResultCount("Sample", resultCount);~~
81		~~results.setHeaders(sp.getHeaders());~~
82		~~if (save && results.getErrors().isEmpty()) {~~
83		~~try {~~
84		~~commit();~~
85		~~} catch (DAOException e) {~~
86		~~results.addError(0, e);~~
87		}
88		}
89		~~} catch (MpDbException e) {~~
90		~~results.addError(-1, e);~~
91		~~} catch (final Exception e) {~~
92		~~results.addError(-1, new GenericDAOException(e.getMessage()));~~
93	55	}
94		re~~turn results~~;
	56	results.addResultCount("Sample", resultCount);
95	57	}
96
97
98	58	}

trunk/mpdb-server/src/edu/rpi/metpetdb/server/impl/bulk/upload/BulkUploadService.java

r741	r797
1	1	package edu.rpi.metpetdb.server.impl.bulk.upload;
2	2
	3	import java.io.FileNotFoundException;
	4	import java.util.Collection;
	5	import java.util.HashMap;
	6	import java.util.HashSet;
3	7	import java.util.Iterator;
4	8	import java.util.Map;
	9	import java.util.Set;
5	10
6	11	import org.hibernate.HibernateException;
	12	import org.hibernate.exception.GenericJDBCException;
7	13
8	14	import edu.rpi.metpetdb.client.error.DAOException;
9	15	import edu.rpi.metpetdb.client.error.LoginRequiredException;
10	16	import edu.rpi.metpetdb.client.error.MpDbException;
	17	import edu.rpi.metpetdb.client.error.ValidationException;
	18	import edu.rpi.metpetdb.client.error.dao.GenericDAOException;
	19	import edu.rpi.metpetdb.client.error.validation.PropertyRequiredException;
	20	import edu.rpi.metpetdb.client.model.Sample;
	21	import edu.rpi.metpetdb.client.model.Subsample;
11	22	import edu.rpi.metpetdb.client.model.User;
	23	import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadError;
12	24	import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadResult;
13	25	import edu.rpi.metpetdb.client.model.bulk.upload.BulkUploadResultCount;
14	26	import edu.rpi.metpetdb.client.model.interfaces.HasOwner;
	27	import edu.rpi.metpetdb.client.model.interfaces.HasSample;
	28	import edu.rpi.metpetdb.client.model.interfaces.HasSubsample;
15	29	import edu.rpi.metpetdb.client.model.interfaces.MObject;
16	30	import edu.rpi.metpetdb.client.model.interfaces.PublicData;
17	31	import edu.rpi.metpetdb.server.MpDbServlet;
	32	import edu.rpi.metpetdb.server.bulk.upload.NewParser;
18	33	import edu.rpi.metpetdb.server.dao.MpDbDAO;
	34	import edu.rpi.metpetdb.server.dao.impl.SampleDAO;
	35	import edu.rpi.metpetdb.server.dao.impl.SubsampleDAO;
19	36
20	37	/**
…	…
27	44
28	45	private static final long serialVersionUID = 1L;
	46
	47	public BulkUploadResult parser(String fileOnServer, boolean save)
	48	throws LoginRequiredException, DAOException {
	49	final BulkUploadResult results = new BulkUploadResult();
	50	try {
	51	if (save) {
	52	updateFile(fileOnServer);
	53	}
	54	final SampleDAO sampleDao = new SampleDAO(this.currentSession());
	55	final SubsampleDAO ssDAO = new SubsampleDAO(this.currentSession());
	56
	57	// Keeps track of existing/new subsample names for each sample
	58	final Map<String, Collection<String>> subsampleNames = new HashMap<String, Collection<String>>();
	59	// maps a sample alias to an actual sample
	60	final Map<String, Sample> samples = new HashMap<String, Sample>();
	61	// maps a sample alias + subsample name to an actual subsample
	62	final Map<String, Subsample> subsamples = new HashMap<String, Subsample>();
	63
	64	parserImpl(fileOnServer, save, results, sampleDao, ssDAO,
	65	subsampleNames, samples, subsamples);
	66
	67	if (save && results.getErrors().isEmpty()) {
	68	try {
	69	commit();
	70	} catch (Exception e) {
	71	results.addError(0, getNiceException(e));
	72	}
	73	}
	74	} catch (LoginRequiredException e) {
	75	throw e; // so that it does not get caught below
	76	} catch (final Exception e) {
	77	results.addError(-1, getNiceException(e));
	78	}
	79	return results;
	80	}
	81
	82	public abstract void parserImpl(String fileOnServer, boolean save,
	83	BulkUploadResult results, SampleDAO sampleDao, SubsampleDAO ssDao,
	84	final Map<String, Collection<String>> subsampleNames,
	85	final Map<String, Sample> samples,
	86	final Map<String, Subsample> subsamples)
	87	throws FileNotFoundException, MpDbException, LoginRequiredException;
29	88
30	89	/**
…	…
41	100	.createSQLQuery(
42	101	"UPDATE uploaded_files SET user_id = :user_id WHERE hash = :hash")
43		.setParameter("user_id", currentUser()).setParameter("hash",
	102	.setParameter("user_id", currentUserId()).setParameter("hash",
44	103	fileOnServer).executeUpdate();
45	104	}
46	105
	106	protected void addErrors(final NewParser<?> parser,
	107	final BulkUploadResult results) {
	108	final Map<Integer, BulkUploadError> existingErrors = parser.getErrors();
	109	final Set<Integer> keys = existingErrors.keySet();
	110	final Iterator<Integer> itr = keys.iterator();
	111	while (itr.hasNext()) {
	112	final Integer i = itr.next();
	113	results.addError(i.intValue(), existingErrors.get(i).getColumn(),
	114	existingErrors.get(i).getCellData(),
	115	getNiceException(existingErrors.get(i).getException()));
	116	}
	117	}
	118
	119	protected MpDbException getNiceException(final Exception e) {
	120	return getNiceException(e, null);
	121	}
	122
	123	protected MpDbException getNiceException(final Exception e,
	124	final MObject obj) {
	125	e.printStackTrace();
	126	if (e instanceof MpDbException) {
	127	return (MpDbException) e;
	128	} else if (e instanceof GenericJDBCException) {
	129	if (((GenericJDBCException) e).getSQLException().getSQLState()
	130	.equals("25P02")) {
	131	return new GenericDAOException(
	132	"Bulk Upload stopped due to fatal error");
	133	} else {
	134	return new GenericDAOException(e.getMessage());
	135	}
	136	} else if (e instanceof HibernateException) {
	137	return handleHibernateException((HibernateException) e, obj);
	138	} else {
	139	return null;
	140	}
	141
	142	}
	143	protected <T extends MObject> void initObject(T obj)
	144	throws LoginRequiredException, DAOException {
	145	if (obj instanceof HasOwner)
	146	((HasOwner) obj).setOwner(currentUser());
	147	if (obj instanceof PublicData)
	148	((PublicData) obj).setPublicData(false);
	149	if (obj instanceof HasSubsample) {
	150	((HasSubsample) obj).getSubsample().setOwner(currentUser());
	151	((HasSubsample) obj).getSubsample().setPublicData(false);
	152	}
	153	if (obj instanceof HasSample) {
	154	((HasSample)obj).getSample().setOwner(currentUser());
	155	}
	156	}
	157
	158	protected boolean checkForSample(Sample s,
	159	final Map<String, Sample> samples, final SampleDAO sampleDao,
	160	final BulkUploadResult results,
	161	final Map<String, Collection<String>> subsampleNames, int row) {
	162	try {
	163	// if we don't have this sample already loaded check
	164	// for it in the database
	165	if (!samples.containsKey(s.getAlias())) {
	166	s = sampleDao.fill(s);
	167	samples.put(s.getAlias(), s);
	168	subsampleNames.put(s.getAlias(), new HashSet<String>());
	169	} else {
	170	s = samples.get(s.getAlias());
	171	}
	172	return true;
	173	} catch (DAOException e) {
	174	// There is no sample we have to add an error
	175	// Every Image needs a sample so add an error
	176	results.addError(row, new PropertyRequiredException("Sample"));
	177	results.addError(row, e);
	178	return false;
	179	}
	180	}
	181
	182	protected Subsample checkForSubsample(Sample s, Subsample ss,
	183	final Map<String, Sample> samples, final SubsampleDAO ssDao,
	184	final BulkUploadResult results,
	185	final Map<String, Collection<String>> subsampleNames, int row,
	186	final Map<String, Subsample> subsamples,
	187	BulkUploadResultCount ssResultCount, boolean save)
	188	throws ValidationException {
	189	if (subsampleNames.get(s.getAlias()) != null
	190	&& !subsampleNames.get(s.getAlias()).contains(ss.getName())) {
	191	try {
	192	doc.validate(ss);
	193	ss = ssDao.fill(ss);
	194	subsamples.put(s.getAlias() + ss.getName(), ss);
	195	ssResultCount.incrementOld();
	196	return ss;
	197	} catch (DAOException e) {
	198	// Means it is new because we could not find
	199	// it
	200	ssResultCount.incrementFresh();
	201	if (save) {
	202	try {
	203	ss = ssDao.save(ss);
	204	} catch (DAOException e1) {
	205	results.addError(row, e1);
	206	}
	207	subsamples.put(s.getAlias() + ss.getName(), ss);
	208	return ss;
	209	}
	210	}
	211	subsampleNames.get(s.getAlias()).add(ss.getName());
	212	return ss;
	213	} else {
	214	return subsamples.get(s.getAlias() + ss.getName());
	215	}
	216	}
47	217	protected <T extends MObject> void analyzeResults(
48	218	final Map<Integer, T> results,
…	…
51	221	final MpDbDAO<T> dao) throws LoginRequiredException {
52	222	final User user = new User();
53		user.setId(currentUser());
	223	user.setId(currentUserId());
54	224	final Iterator<Integer> rows = results.keySet().iterator();
55	225	while (rows.hasNext()) {
56	226	final int row = rows.next();
57	227	final T result = results.get(row);
58		if (result instanceof HasOwner)
59		((HasOwner) result).setOwner(user);
60		if (result instanceof PublicData)
61		((PublicData) result).setPublicData(false);
	228
62	229	try {
63		//validate(result);
	230	// validate(result);
64	231	if (dao.isNew(result))
65	232	resultCount.incrementFresh();

Context Navigation

Changeset 797

Legend:

Download in other formats: