1 package fr.ifremer.tutti.ui.swing.content.genericformat;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 import fr.ifremer.tutti.persistence.entities.data.Program;
28 import fr.ifremer.tutti.persistence.model.CruiseDataModel;
29 import fr.ifremer.tutti.persistence.model.ProgramDataModel;
30 import fr.ifremer.tutti.service.genericformat.GenericFormatImportConfiguration;
31 import fr.ifremer.tutti.service.genericformat.GenericFormatImportResult;
32 import fr.ifremer.tutti.service.genericformat.GenericFormatValidateFileResult;
33 import fr.ifremer.tutti.ui.swing.content.genericformat.tree.ProgramSelectTreeNode;
34 import org.jdesktop.beans.AbstractSerializableBean;
35
36 import java.io.File;
37 import java.util.Collections;
38
39
40
41
42
43
44
45 public class GenericFormatImportUIModel extends AbstractSerializableBean {
46
47 private static final long serialVersionUID = 1L;
48
49 public static final String PROPERTY_PROGRAM = "program";
50
51 public static final String PROPERTY_IMPORT_FILE = "importFile";
52
53 public static final String PROPERTY_CLEAN_WEIGHTS = "cleanWeights";
54
55 public static final String PROPERTY_CHECK_WEIGHTS = "checkWeights";
56
57 public static final String PROPERTY_IMPORT_ATTACHMENTS = "importAttachments";
58
59 public static final String PROPERTY_IMPORT_SPECIES = "importSpecies";
60
61 public static final String PROPERTY_IMPORT_BENTHOS = "importBenthos";
62
63 public static final String PROPERTY_IMPORT_MARINE_LITTER = "importMarineLitter";
64
65 public static final String PROPERTY_IMPORT_ACCIDENTAL_CATCH = "importAccidentalCatch";
66
67 public static final String PROPERTY_IMPORT_INDIVIDUAL_OBSERVATION = "importIndividualObservation";
68
69 public static final String PROPERTY_UPDATE_CRUISES = "updateCruises";
70
71 public static final String PROPERTY_UPDATE_OPERATIONS = "updateOperations";
72
73 public static final String PROPERTY_CAN_VALIDATE = "canValidate";
74
75 public static final String PROPERTY_VALIDATE_RESULT = "validateResult";
76
77 public static final String PROPERTY_VALIDATE_VALID = "validateValid";
78
79 public static final String PROPERTY_VALIDATE_DONE = "validateDone";
80
81 public static final String PROPERTY_CAN_IMPORT = "canImport";
82
83 public static final String PROPERTY_IMPORT_RESULT = "importResult";
84
85 public static final String PROPERTY_IMPORT_DONE = "importDone";
86
87 public static final String PROPERTY_IMPORT_VALID = "importValid";
88
89 public static final String PROPERTY_DATA_SELECTED = "dataSelected";
90
91 public static final String PROPERTY_AUTHORIZE_OBSOLETE_REFERENTIALS = "authorizeObsoleteReferentials";
92
93 private Program program;
94
95 private File importFile;
96
97 private boolean updateCruises = true;
98
99 private boolean updateOperations = true;
100
101 private boolean importSpecies = true;
102
103 private boolean importBenthos = true;
104
105 private boolean importMarineLitter = true;
106
107 private boolean importAccidentalCatch = true;
108
109 private boolean importIndividualObservation = true;
110
111 private boolean importAttachments = true;
112
113 private boolean cleanWeights;
114
115 private boolean checkWeights;
116
117 private boolean canValidate;
118
119 private boolean authorizeObsoleteReferentials;
120
121 private File validateReportFile;
122
123 private GenericFormatValidateFileResult validateResult;
124
125 private boolean canImport;
126
127 private File importReportFile;
128
129 private GenericFormatImportResult importResult;
130
131 private ProgramSelectTreeNode rootNode;
132
133 private boolean dataSelected;
134
135 public GenericFormatImportConfiguration toValidateImportFileConfiguration(int maximumRowsInErrorsPerFile) {
136
137 GenericFormatImportConfiguration configuration = new GenericFormatImportConfiguration();
138
139 ProgramDataModel selectedDataModel = new ProgramDataModel(program, Collections.<CruiseDataModel>emptySet());
140 configuration.setDataToExport(selectedDataModel);
141
142 configuration.setMaximumRowsInErrorPerFile(maximumRowsInErrorsPerFile);
143
144 configuration.setImportSpecies(importSpecies);
145 configuration.setImportBenthos(importBenthos);
146 configuration.setImportMarineLitter(importMarineLitter);
147 configuration.setImportAccidentalCatch(importAccidentalCatch);
148 configuration.setImportIndividualObservation(importIndividualObservation);
149 configuration.setImportAttachments(importAttachments);
150 configuration.setAuthorizeObsoleteReferentials(authorizeObsoleteReferentials);
151
152 configuration.setCleanWeights(cleanWeights);
153 configuration.setCheckWeights(checkWeights);
154
155 configuration.setImportFile(importFile);
156 configuration.setReportFile(validateReportFile);
157
158 return configuration;
159
160 }
161
162 public GenericFormatImportConfiguration toImportConfiguration() {
163
164 GenericFormatImportConfiguration configuration = new GenericFormatImportConfiguration();
165
166 ProgramDataModel selectedDataModel = rootNode.getSelectedDataModel();
167 configuration.setDataToExport(selectedDataModel);
168
169 configuration.setUpdateCruises(updateCruises);
170 configuration.setUpdateOperations(updateOperations);
171
172 configuration.setImportSpecies(importSpecies);
173 configuration.setImportBenthos(importBenthos);
174 configuration.setImportMarineLitter(importMarineLitter);
175 configuration.setImportAccidentalCatch(importAccidentalCatch);
176 configuration.setImportIndividualObservation(importIndividualObservation);
177 configuration.setImportAttachments(importAttachments);
178 configuration.setAuthorizeObsoleteReferentials(authorizeObsoleteReferentials);
179
180 configuration.setCleanWeights(cleanWeights);
181 configuration.setCheckWeights(checkWeights);
182 configuration.setImportFile(importFile);
183 configuration.setReportFile(importReportFile);
184
185 return configuration;
186
187 }
188
189 public boolean isSelectedDataExists(boolean isUpdateCruises) {
190 return rootNode.isSelectedDataExists(isUpdateCruises);
191 }
192
193 public Program getProgram() {
194 return program;
195 }
196
197 public void setProgram(Program program) {
198 Object oldValue = getProgram();
199 this.program = program;
200 firePropertyChange(PROPERTY_PROGRAM, oldValue, program);
201 }
202
203 public File getImportFile() {
204 return importFile;
205 }
206
207 public void setImportFile(File importFile) {
208 Object oldValue = getImportFile();
209 this.importFile = importFile;
210 firePropertyChange(PROPERTY_IMPORT_FILE, oldValue, importFile);
211 firePropertyChange(PROPERTY_VALIDATE_VALID, null, isValidateValid());
212 }
213
214 public boolean isCleanWeights() {
215 return cleanWeights;
216 }
217
218 public void setCleanWeights(boolean cleanWeights) {
219 this.cleanWeights = cleanWeights;
220 firePropertyChange(PROPERTY_CLEAN_WEIGHTS, null, cleanWeights);
221 }
222
223 public boolean isCheckWeights() {
224 return checkWeights;
225 }
226
227 public void setCheckWeights(boolean checkWeights) {
228 this.checkWeights = checkWeights;
229 firePropertyChange(PROPERTY_CHECK_WEIGHTS, null, checkWeights);
230 }
231
232 public boolean isUpdateCruises() {
233 return updateCruises;
234 }
235
236 public void setUpdateCruises(boolean updateCruises) {
237 this.updateCruises = updateCruises;
238 firePropertyChange(PROPERTY_UPDATE_CRUISES, null, updateCruises);
239 }
240
241 public boolean isUpdateOperations() {
242 return updateOperations;
243 }
244
245 public void setUpdateOperations(boolean updateOperations) {
246 this.updateOperations = updateOperations;
247 firePropertyChange(PROPERTY_UPDATE_OPERATIONS, null, updateOperations);
248 }
249
250 public boolean isImportSpecies() {
251 return importSpecies;
252 }
253
254 public void setImportSpecies(boolean importSpecies) {
255 this.importSpecies = importSpecies;
256 firePropertyChange(PROPERTY_IMPORT_SPECIES, null, importSpecies);
257 }
258
259 public boolean isImportBenthos() {
260 return importBenthos;
261 }
262
263 public void setImportBenthos(boolean importBenthos) {
264 this.importBenthos = importBenthos;
265 firePropertyChange(PROPERTY_IMPORT_BENTHOS, null, importBenthos);
266 }
267
268 public boolean isImportMarineLitter() {
269 return importMarineLitter;
270 }
271
272 public void setImportMarineLitter(boolean importMarineLitter) {
273 this.importMarineLitter = importMarineLitter;
274 firePropertyChange(PROPERTY_IMPORT_MARINE_LITTER, null, importMarineLitter);
275 }
276
277 public boolean isImportAccidentalCatch() {
278 return importAccidentalCatch;
279 }
280
281 public void setImportAccidentalCatch(boolean importAccidentalCatch) {
282 this.importAccidentalCatch = importAccidentalCatch;
283 firePropertyChange(PROPERTY_IMPORT_ACCIDENTAL_CATCH, null, importAccidentalCatch);
284 }
285
286 public boolean isImportIndividualObservation() {
287 return importIndividualObservation;
288 }
289
290 public void setImportIndividualObservation(boolean importIndividualObservation) {
291 this.importIndividualObservation = importIndividualObservation;
292 firePropertyChange(PROPERTY_IMPORT_INDIVIDUAL_OBSERVATION, null, importIndividualObservation);
293 }
294
295 public boolean isImportAttachments() {
296 return importAttachments;
297 }
298
299 public void setImportAttachments(boolean importAttachments) {
300 this.importAttachments = importAttachments;
301 firePropertyChange(PROPERTY_IMPORT_ATTACHMENTS, null, importAttachments);
302 }
303
304 public File getValidateReportFile() {
305 return validateReportFile;
306 }
307
308 public void setValidateReportFile(File validateReportFile) {
309 this.validateReportFile = validateReportFile;
310 }
311
312 public boolean isCanValidate() {
313 return canValidate;
314 }
315
316 public void setCanValidate(boolean canValidate) {
317 this.canValidate = canValidate;
318 firePropertyChange(PROPERTY_CAN_VALIDATE, null, canValidate);
319 }
320
321 public GenericFormatValidateFileResult getValidateResult() {
322 return validateResult;
323 }
324
325 public void setValidateResult(GenericFormatValidateFileResult validateResult) {
326 this.validateResult = validateResult;
327 firePropertyChange(PROPERTY_VALIDATE_RESULT, null, validateResult);
328 firePropertyChange(PROPERTY_VALIDATE_DONE, null, isValidateDone());
329 firePropertyChange(PROPERTY_VALIDATE_VALID, null, isValidateValid());
330 }
331
332 public boolean isValidateDone() {
333 return validateResult != null;
334 }
335
336 public boolean isValidateValid() {
337 return validateResult != null && validateResult.isValid();
338 }
339
340 public boolean isCanImport() {
341 return canImport;
342 }
343
344 public void setCanImport(boolean canImport) {
345 this.canImport = canImport;
346 firePropertyChange(PROPERTY_CAN_IMPORT, null, canImport);
347 }
348
349 public File getImportReportFile() {
350 return importReportFile;
351 }
352
353 public void setImportReportFile(File importReportFile) {
354 this.importReportFile = importReportFile;
355 }
356
357 public GenericFormatImportResult getImportResult() {
358 return importResult;
359 }
360
361 public void setImportResult(GenericFormatImportResult importResult) {
362 this.importResult = importResult;
363 firePropertyChange(PROPERTY_IMPORT_RESULT, null, importResult);
364 firePropertyChange(PROPERTY_IMPORT_DONE, null, isImportDone());
365 firePropertyChange(PROPERTY_IMPORT_VALID, null, isImportValid());
366 }
367
368 public boolean isDataSelected() {
369 return dataSelected;
370 }
371
372 public void setDataSelected(boolean dataSelected) {
373 this.dataSelected = dataSelected;
374 firePropertyChange(PROPERTY_DATA_SELECTED, null, dataSelected);
375 }
376
377 public boolean isAuthorizeObsoleteReferentials() {
378 return authorizeObsoleteReferentials;
379 }
380
381 public void setAuthorizeObsoleteReferentials(boolean authorizeObsoleteReferentials) {
382 Object oldValue = isAuthorizeObsoleteReferentials();
383 this.authorizeObsoleteReferentials = authorizeObsoleteReferentials;
384 firePropertyChange(PROPERTY_AUTHORIZE_OBSOLETE_REFERENTIALS, oldValue, authorizeObsoleteReferentials);
385 }
386
387 public boolean isImportDone() {
388 return importResult != null;
389 }
390
391 public boolean isImportValid() {
392 return importResult != null && importResult.isValid();
393 }
394
395 public boolean computeIsCanValidate() {
396 return program != null && importFile != null && importFile.exists();
397 }
398
399 public boolean computeIsCanImport() {
400 return isValidateDone() && isValidateValid() && isDataSelected() && importResult == null;
401 }
402
403 public void setRootNode(ProgramSelectTreeNode rootNode) {
404 this.rootNode = rootNode;
405 }
406 }