Mercurial > hg > LGDataverses

comparison src/main/java/edu/harvard/iq/dataverse/Template.java @ 10:a50cf11e5178

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rewrite LGDataverse completely upgrading to dataverse4.0
author Zoe Hong <zhong@mpiwg-berlin.mpg.de>
date Tue, 08 Sep 2015 17:00:21 +0200
parents
children
comparison
equal deleted inserted replaced
9:5926d6419569 10:a50cf11e5178
1 package edu.harvard.iq.dataverse;
2
3 import java.io.Serializable;
4 import java.text.SimpleDateFormat;
5 import java.util.ArrayList;
6 import java.util.Collections;
7 import java.util.Comparator;
8 import java.util.Date;
9 import java.util.HashMap;
10 import java.util.LinkedList;
11 import java.util.List;
12 import java.util.Map;
13 import javax.persistence.CascadeType;
14 import javax.persistence.Column;
15 import javax.persistence.Entity;
16 import javax.persistence.GeneratedValue;
17 import javax.persistence.GenerationType;
18 import javax.persistence.Id;
19 import javax.persistence.JoinColumn;
20 import javax.persistence.ManyToOne;
21 import javax.persistence.OneToMany;
22 import javax.persistence.Temporal;
23 import javax.persistence.TemporalType;
24 import javax.persistence.Transient;
25 import javax.validation.constraints.Size;
26 import org.hibernate.validator.constraints.NotBlank;
27
28 /**
29 *
30 * @author skraffmiller
31 */
32 @Entity
33 public class Template implements Serializable {
34
35 @Id
36 @GeneratedValue(strategy = GenerationType.IDENTITY)
37 private Long id;
38
39 public Template() {
40
41 }
42
43 //Constructor for create
44 public Template(Dataverse dataverseIn) {
45 dataverse = dataverseIn;
46 datasetFields = initDatasetFields();
47 initMetadataBlocksForCreate();
48 }
49
50 public Long getId() {
51 return this.id;
52 }
53
54 @NotBlank(message = "Please add in a name for the dataset template.")
55 @Size(max = 255, message = "Name must be at most 255 characters.")
56 @Column( nullable = false )
57 private String name;
58
59 public String getName() {
60 return name;
61 }
62
63 public void setName(String name) {
64 this.name = name;
65 }
66
67 private Long usageCount;
68
69 public Long getUsageCount() {
70 return usageCount;
71 }
72
73 public void setUsageCount(Long usageCount) {
74 this.usageCount = usageCount;
75 }
76
77 @Temporal(value = TemporalType.TIMESTAMP)
78 @Column( nullable = false )
79 private Date createTime;
80
81 public Date getCreateTime() {
82 return createTime;
83 }
84
85 public void setCreateTime(Date createTime) {
86 this.createTime = createTime;
87 }
88
89 public String getCreateDate() {
90 return new SimpleDateFormat("MMMM d, yyyy").format(createTime);
91 }
92
93 @OneToMany(mappedBy = "template", orphanRemoval = true, cascade = {CascadeType.REMOVE, CascadeType.MERGE, CascadeType.PERSIST})
94 //@OrderBy("datasetField.displayOrder")
95 private List<DatasetField> datasetFields = new ArrayList();
96
97 public List<DatasetField> getDatasetFields() {
98 return datasetFields;
99 }
100
101 @Transient
102 private Map<MetadataBlock, List<DatasetField>> metadataBlocksForView = new HashMap();
103 @Transient
104 private Map<MetadataBlock, List<DatasetField>> metadataBlocksForEdit = new HashMap();
105
106 @Transient
107 private boolean isDefaultForDataverse;
108
109 public boolean isIsDefaultForDataverse() {
110 return isDefaultForDataverse;
111 }
112
113 public void setIsDefaultForDataverse(boolean isDefaultForDataverse) {
114 this.isDefaultForDataverse = isDefaultForDataverse;
115 }
116
117 @Transient
118 private List<Dataverse> dataversesHasAsDefault;
119
120 public List<Dataverse> getDataversesHasAsDefault() {
121 return dataversesHasAsDefault;
122 }
123
124 public void setDataversesHasAsDefault(List<Dataverse> dataversesHasAsDefault) {
125 this.dataversesHasAsDefault = dataversesHasAsDefault;
126 }
127
128
129 public Map<MetadataBlock, List<DatasetField>> getMetadataBlocksForView() {
130 return metadataBlocksForView;
131 }
132
133 public void setMetadataBlocksForView(Map<MetadataBlock, List<DatasetField>> metadataBlocksForView) {
134 this.metadataBlocksForView = metadataBlocksForView;
135 }
136
137 public Map<MetadataBlock, List<DatasetField>> getMetadataBlocksForEdit() {
138 return metadataBlocksForEdit;
139 }
140
141 public void setMetadataBlocksForEdit(Map<MetadataBlock, List<DatasetField>> metadataBlocksForEdit) {
142 this.metadataBlocksForEdit = metadataBlocksForEdit;
143 }
144
145 @ManyToOne
146 @JoinColumn(nullable=true)
147 private Dataverse dataverse;
148
149 public Dataverse getDataverse() {
150 return dataverse;
151 }
152
153 public void setDataverse(Dataverse dataverse) {
154 this.dataverse = dataverse;
155 }
156
157 private List<DatasetField> initDatasetFields() {
158 //retList - Return List of values
159 List<DatasetField> retList = new ArrayList();
160 for (DatasetField dsf : this.getDatasetFields()) {
161 retList.add(initDatasetField(dsf));
162 }
163
164 //Test to see that there are values for
165 // all fields in this dataset via metadata blocks
166 //only add if not added above
167 for (MetadataBlock mdb : this.getDataverse().getMetadataBlocks()) {
168 for (DatasetFieldType dsfType : mdb.getDatasetFieldTypes()) {
169 if (!dsfType.isSubField()) {
170 boolean add = true;
171 //don't add if already added as a val
172 for (DatasetField dsf : retList) {
173 if (dsfType.equals(dsf.getDatasetFieldType())) {
174 add = false;
175 break;
176 }
177 }
178
179 if (add) {
180 retList.add(DatasetField.createNewEmptyDatasetField(dsfType, this));
181 }
182 }
183 }
184 }
185
186 //sort via display order on dataset field
187 Collections.sort(retList, new Comparator<DatasetField>() {
188 public int compare(DatasetField d1, DatasetField d2) {
189 int a = d1.getDatasetFieldType().getDisplayOrder();
190 int b = d2.getDatasetFieldType().getDisplayOrder();
191 return Integer.valueOf(a).compareTo(Integer.valueOf(b));
192 }
193 });
194
195 return sortDatasetFields(retList);
196 }
197
198 private List<DatasetField> sortDatasetFields(List<DatasetField> dsfList) {
199 Collections.sort(dsfList, new Comparator<DatasetField>() {
200 public int compare(DatasetField d1, DatasetField d2) {
201 int a = d1.getDatasetFieldType().getDisplayOrder();
202 int b = d2.getDatasetFieldType().getDisplayOrder();
203 return Integer.valueOf(a).compareTo(Integer.valueOf(b));
204 }
205 });
206 return dsfList;
207 }
208
209 private void initMetadataBlocksForCreate() {
210 metadataBlocksForView.clear();
211 metadataBlocksForEdit.clear();
212 for (MetadataBlock mdb : this.getDataverse().getMetadataBlocks()) {
213 List<DatasetField> datasetFieldsForView = new ArrayList();
214 List<DatasetField> datasetFieldsForEdit = new ArrayList();
215 for (DatasetField dsf : this.getDatasetFields()) {
216
217 if (dsf.getDatasetFieldType().getMetadataBlock().equals(mdb)) {
218 datasetFieldsForEdit.add(dsf);
219 }
220 }
221
222 if (!datasetFieldsForView.isEmpty()) {
223 metadataBlocksForView.put(mdb, sortDatasetFields(datasetFieldsForView));
224 }
225 if (!datasetFieldsForEdit.isEmpty()) {
226 metadataBlocksForEdit.put(mdb, sortDatasetFields(datasetFieldsForEdit));
227 }
228 }
229 }
230
231 public void setMetadataValueBlocks() {
232 //TODO: A lot of clean up on the logic of this method
233 metadataBlocksForView.clear();
234 metadataBlocksForEdit.clear();
235 List<DatasetField> filledInFields = this.getDatasetFields();
236
237
238 List <MetadataBlock> actualMDB = new ArrayList();
239
240 actualMDB.addAll(this.getDataverse().getMetadataBlocks());
241 for (DatasetField dsfv : filledInFields) {
242 if (!dsfv.isEmptyForDisplay()) {
243 MetadataBlock mdbTest = dsfv.getDatasetFieldType().getMetadataBlock();
244 if (!actualMDB.contains(mdbTest)) {
245 actualMDB.add(mdbTest);
246 }
247 }
248 }
249
250 for (MetadataBlock mdb : actualMDB) {
251 List<DatasetField> datasetFieldsForView = new ArrayList();
252 List<DatasetField> datasetFieldsForEdit = new ArrayList();
253 for (DatasetField dsf : this.getDatasetFields()) {
254 if (dsf.getDatasetFieldType().getMetadataBlock().equals(mdb)) {
255 datasetFieldsForEdit.add(dsf);
256 if (!dsf.isEmpty()) {
257 datasetFieldsForView.add(dsf);
258 }
259 }
260 }
261
262 if (!datasetFieldsForView.isEmpty()) {
263 metadataBlocksForView.put(mdb, sortDatasetFields(datasetFieldsForView));
264 }
265 if (!datasetFieldsForEdit.isEmpty()) {
266 metadataBlocksForEdit.put(mdb, sortDatasetFields(datasetFieldsForEdit));
267 }
268 }
269 }
270
271 // TODO: clean up init methods and get them to work, cascading all the way down.
272 // right now, only work for one level of compound objects
273 private DatasetField initDatasetField(DatasetField dsf) {
274 if (dsf.getDatasetFieldType().isCompound()) {
275 for (DatasetFieldCompoundValue cv : dsf.getDatasetFieldCompoundValues()) {
276 // for each compound value; check the datasetfieldTypes associated with its type
277 for (DatasetFieldType dsfType : dsf.getDatasetFieldType().getChildDatasetFieldTypes()) {
278 boolean add = true;
279 for (DatasetField subfield : cv.getChildDatasetFields()) {
280 if (dsfType.equals(subfield.getDatasetFieldType())) {
281 add = false;
282 break;
283 }
284 }
285
286 if (add) {
287 cv.getChildDatasetFields().add(DatasetField.createNewEmptyChildDatasetField(dsfType, cv));
288 }
289 }
290
291 sortDatasetFields(cv.getChildDatasetFields());
292 }
293 }
294
295 return dsf;
296 }
297
298 public Template cloneNewTemplate(Template source) {
299 Template newTemplate = new Template();
300 Template latestVersion = source;
301 //if the latest version has values get them copied over
302 if (latestVersion.getDatasetFields() != null && !latestVersion.getDatasetFields().isEmpty()) {
303 newTemplate.setDatasetFields(newTemplate.copyDatasetFields(source.getDatasetFields()));
304 }
305 return newTemplate;
306 }
307
308 public List<DatasetField> copyDatasetFields(List<DatasetField> copyFromList) {
309 List<DatasetField> retList = new ArrayList();
310
311 for (DatasetField sourceDsf : copyFromList) {
312 //the copy needs to have the current version
313 retList.add(sourceDsf.copy(this));
314 }
315
316 return retList;
317 }
318
319 public void setDatasetFields(List<DatasetField> datasetFields) {
320 for (DatasetField dsf : datasetFields) {
321 dsf.setTemplate(this);
322 }
323 this.datasetFields = datasetFields;
324 }
325
326 public List<DatasetField> getFlatDatasetFields() {
327 return getFlatDatasetFields(getDatasetFields());
328 }
329
330 private List<DatasetField> getFlatDatasetFields(List<DatasetField> dsfList) {
331 List<DatasetField> retList = new LinkedList();
332 for (DatasetField dsf : dsfList) {
333 retList.add(dsf);
334 if (dsf.getDatasetFieldType().isCompound()) {
335 for (DatasetFieldCompoundValue compoundValue : dsf.getDatasetFieldCompoundValues()) {
336 retList.addAll(getFlatDatasetFields(compoundValue.getChildDatasetFields()));
337 }
338
339 }
340 }
341 return retList;
342 }
343
344 @Override
345 public int hashCode() {
346 int hash = 0;
347 hash += (this.id != null ? this.id.hashCode() : 0);
348 return hash;
349 }
350
351 @Override
352 public boolean equals(Object object) {
353 // TODO: Warning - this method won't work in the case the id fields are not set
354 if (!(object instanceof Template)) {
355 return false;
356 }
357 Template other = (Template) object;
358 if (this.id != other.id && (this.id == null || !this.id.equals(other.id))) {
359 return false;
360 }
361 return true;
362 }
363
364 }