1 package com.atlassian.jira.util.entities;
2
3 import java.util.ArrayList;
4 import java.util.Arrays;
5 import java.util.HashMap;
6 import java.util.Iterator;
7 import java.util.List;
8 import java.util.Locale;
9 import java.util.Map;
10 import java.util.regex.Pattern;
11
12 import org.apache.log4j.Category;
13 import org.ofbiz.core.entity.GenericEntityException;
14 import org.ofbiz.core.entity.GenericValue;
15
16 import com.atlassian.jira.ComponentManager;
17 import com.atlassian.jira.ManagerFactory;
18 import com.atlassian.jira.config.ConstantsManager;
19 import com.atlassian.jira.event.type.EventType;
20 import com.atlassian.jira.event.type.EventTypeManager;
21 import com.atlassian.jira.issue.CustomFieldManager;
22 import com.atlassian.jira.issue.IssueConstant;
23 import com.atlassian.jira.issue.context.IssueContext;
24 import com.atlassian.jira.issue.context.IssueContextImpl;
25 import com.atlassian.jira.issue.context.manager.JiraContextTreeManager;
26 import com.atlassian.jira.issue.customfields.CustomFieldSearcher;
27 import com.atlassian.jira.issue.customfields.CustomFieldType;
28 import com.atlassian.jira.issue.customfields.CustomFieldUtils;
29 import com.atlassian.jira.issue.customfields.MultipleSettableCustomFieldType;
30 import com.atlassian.jira.issue.customfields.RegExpCFType;
31 import com.atlassian.jira.issue.customfields.impl.CascadingSelectCFType;
32 import com.atlassian.jira.issue.customfields.impl.SelectCFType;
33 import com.atlassian.jira.issue.customfields.manager.OptionsManager;
34 import com.atlassian.jira.issue.customfields.option.Option;
35 import com.atlassian.jira.issue.customfields.option.Options;
36 import com.atlassian.jira.issue.customfields.view.CustomFieldParamsImpl;
37 import com.atlassian.jira.issue.fields.CustomField;
38 import com.atlassian.jira.issue.fields.CustomFieldImpl;
39 import com.atlassian.jira.issue.fields.config.FieldConfig;
40 import com.atlassian.jira.issue.fields.config.FieldConfigScheme;
41 import com.atlassian.jira.issue.fields.config.manager.FieldConfigSchemeManager;
42 import com.atlassian.jira.issue.fields.config.manager.IssueTypeSchemeManager;
43 import com.atlassian.jira.issue.fields.option.OptionSetManager;
44 import com.atlassian.jira.issue.fields.screen.FieldScreenManager;
45 import com.atlassian.jira.project.ProjectManager;
46 import com.atlassian.jira.upgrade.UpgradeHelper;
47 import com.atlassian.jira.util.ObjectUtils;
48 import com.atlassian.jira.web.action.admin.customfields.CustomFieldValidator;
49
50
51
52
53
54
55
56
57
58 public class EntitiesHelper {
59
60 private static Category log = Category.getInstance(EntitiesHelper.class);
61
62 private static EntitiesHelper instance;
63
64 private static OptionsManager optionsManager;
65
66 private static CustomFieldManager customFieldManager;
67
68 private static CustomFieldValidator customFieldValidator;
69
70 private static ProjectManager projectManager;
71
72 private static ConstantsManager constantsManager;
73
74 private static FieldScreenManager fieldScreenManager;
75
76 private static JiraContextTreeManager treeManager;
77
78 private static FieldConfigSchemeManager fieldConfigSchemeManager;
79
80 private static IssueTypeSchemeManager issueTypeSchemeManager;
81
82 private static EventTypeManager eventTypeManager;
83
84 private static OptionSetManager optionSetManager;
85
86
87
88 protected EntitiesHelper() {
89 optionsManager = ManagerFactory.getOptionsManager();
90 customFieldManager = ManagerFactory.getCustomFieldManager();
91 customFieldValidator = ManagerFactory.getCustomFieldValidator();
92 projectManager = ManagerFactory.getProjectManager();
93 constantsManager = ManagerFactory.getConstantsManager();
94 fieldScreenManager = ComponentManager.getInstance().getFieldScreenManager();
95 treeManager = (JiraContextTreeManager) ComponentManager.getComponentInstanceOfType(JiraContextTreeManager.class);
96 fieldConfigSchemeManager = (FieldConfigSchemeManager) ComponentManager.getComponentInstanceOfType(FieldConfigSchemeManager.class);
97 issueTypeSchemeManager = (IssueTypeSchemeManager) ComponentManager.getComponentInstanceOfType(IssueTypeSchemeManager.class);
98 eventTypeManager = (EventTypeManager) ComponentManager.getComponentInstanceOfType(EventTypeManager.class);
99 optionSetManager = (OptionSetManager) ComponentManager.getComponentInstanceOfType(OptionSetManager.class);
100 }
101
102
103
104 public static EntitiesHelper getInstance() {
105 if (instance == null) {
106 instance = new EntitiesHelper();
107 }
108 return instance;
109 }
110
111
112
113
114 public Priority addPriority(final int _id, final String _name, final String _statusColor, final String _iconURL, final String _description) throws GenericEntityException {
115
116 Priority priority = new Priority();
117
118 priority.setId(_id);
119 priority.setName(_name);
120 priority.setIconURL(_iconURL);
121 priority.setDescription(_description);
122 priority.setStatusColor(_statusColor);
123 priority.store();
124
125 return priority;
126 }
127
128
129
130
131 public Resolution addResolution(final int _id, final String _name, final String _iconURL, final String _description) throws GenericEntityException {
132
133 Resolution resolution = new Resolution();
134
135 resolution.setId(_id);
136 resolution.setName(_name);
137 resolution.setDescription(_description);
138 resolution.store();
139
140 return resolution;
141 }
142
143
144
145
146 public Status addStatus(final int _id, final String _name, final String _iconURL, final String _description) throws GenericEntityException {
147
148 Status status = new Status();
149
150 status.setId(_id);
151 status.setName(_name);
152 status.setIconURL(_iconURL);
153 status.setDescription(_description);
154 status.store();
155
156 return status;
157 }
158
159
160
161
162 public Component addComponent(final int _project, final String _lead, final String _name, final String _description, final String _url, final long _assigneeType) throws GenericEntityException {
163
164 Component component = new Component();
165
166
167 component.setName(_name);
168 if (_description == null) {
169 component.setDescription(_name);
170 } else {
171 component.setDescription(_description);
172 }
173 component.setAssigneeType(_assigneeType);
174 component.setProject(_project);
175 component.setUrl(_url);
176 component.setLead(_lead);
177
178 component.store();
179
180 return component;
181 }
182
183
184
185
186 public IssueType addIssueType(final int _id, final String _name, final String _style, final String _iconURL, final String _description) throws GenericEntityException {
187
188 IssueType issueType = new IssueType();
189
190 issueType.setId(_id);
191 issueType.setName(_name);
192 issueType.setStyle(_style);
193 issueType.setIconURL(_iconURL);
194 issueType.setDescription(_description);
195 issueType.store();
196
197
198 String issueTypeId = String.valueOf(issueType.getId());
199 if (isIssueTypeInDefault(issueTypeId )) {
200 issueTypeSchemeManager.addOptionToDefault(issueTypeId );
201 }
202
203 return issueType;
204 }
205
206 public boolean isIssueTypeInDefault(String _id) {
207 FieldConfigScheme defaultIssueTypeScheme = issueTypeSchemeManager.getDefaultIssueTypeScheme();
208 List optionIds = new ArrayList(optionSetManager.getOptionsForConfig(defaultIssueTypeScheme.getOneAndOnlyConfig()).getOptionIds());
209 return optionIds.contains(_id);
210 }
211
212
213
214
215 public void translateIssueConstant(final Locale locale, final String _constantType, final int _id, final String _translatedName, final String _translatedDesc) {
216
217 IssueConstant issueConstant = constantsManager.getConstantObject(_constantType, String.valueOf(_id));
218 issueConstant.setTranslation(_translatedName, _translatedDesc, null, locale);
219
220 return;
221 }
222
223
224
225
226 public CustomField addCustomFields(final String _fieldName, final String _fieldScope, final String _fieldDescription, final String _fieldType, final String _fieldSearcher, final String _issueType,
227 final String _projectKey) throws GenericEntityException {
228 return addCustomFields(_fieldName, _fieldScope, _fieldDescription, _fieldType, _fieldSearcher, (List) Arrays.asList(new String[] { getIssueTypeId(_issueType) }), (List) Arrays
229 .asList(new Long[] { getProject(_projectKey) }), false);
230 }
231
232
233
234
235 public CustomField addCustomFields(final String _fieldName, final String _fieldScope, final String _fieldDescription, final String _fieldType, final String _fieldSearcher, final List _issueTypes,
236 final List _projects, final boolean _update, final Map _patterns) throws GenericEntityException {
237 return addCustomFields(_fieldName, _fieldScope, _fieldDescription, _fieldType, _fieldSearcher, _issueTypes, _projects, _update, _patterns.get(_fieldName));
238 }
239
240
241
242
243 public CustomField addCustomFields(final String _fieldName, final String _fieldScope, final String _fieldDescription, final String _fieldType, final String _fieldSearcher, final List _issueTypes,
244 final List _projects, final Map _patterns) throws GenericEntityException {
245 return addCustomFields(_fieldName, _fieldScope, _fieldDescription, _fieldType, _fieldSearcher, _issueTypes, _projects, false, _patterns.get(_fieldName));
246 }
247
248
249
250
251 public CustomField addCustomFields(final String _fieldName, final String _fieldScope, final String _fieldDescription, final String _fieldType, final String _fieldSearcher, final List _issueTypes,
252 final List _projects, final boolean _update, final Object _defaultValue) throws GenericEntityException {
253 FieldConfig fc = null;
254 CustomField cf = null;
255 CustomFieldType cft = null;
256 IssueContext ic = new IssueContextImpl((Long)null,(String)null);
257 cf = addCustomFields(_fieldName, _fieldScope, _fieldDescription, _fieldType, _fieldSearcher, _issueTypes, _projects, _update);
258 if (_defaultValue != null) {
259 cft = cf.getCustomFieldType();
260 fc = getDefaultFieldConfig(cf, ic);
261 if (cft instanceof RegExpCFType && _defaultValue instanceof Pattern) {
262 cft.setDefaultValue(fc, ((Pattern)_defaultValue).pattern());
263 } else {
264 cft.setDefaultValue(fc, _defaultValue);
265 }
266 }
267 return cf;
268 }
269
270
271
272
273 public CustomField addCustomFields(final String _fieldName, final String _fieldScope, final String _fieldDescription, final String _fieldType, final String _fieldSearcher, final List _issueTypes,
274 final List _projects) throws GenericEntityException {
275 return addCustomFields(_fieldName, _fieldScope, _fieldDescription, _fieldType, _fieldSearcher, _issueTypes, _projects, false);
276 }
277
278
279
280
281
282
283
284
285
286
287
288
289 public CustomField addCustomFields(final String _fieldName, final String _fieldScope, final String _fieldDescription, final String _fieldType, final String _fieldSearcher, final List _issueTypes,
290 final List _projects, final boolean _updateCFType) throws GenericEntityException {
291 Long[] projects = null;
292 if (_projects == null) {
293 projects = new Long[0];
294 } else {
295 projects = new Long[_projects.size()];
296 _projects.toArray(projects);
297 }
298 Long[] categories = new Long[0];
299
300 CustomField createdCustomField = null;
301
302 log.info("... Adding CustomField [" + _fieldName + "] with");
303 log.info("......... FieldSearcher [" + _fieldSearcher + "]");
304 log.info("......... FieldDescription [" + _fieldDescription + "]");
305 log.info("......... FieldType [" + _fieldType + "]");
306
307 CustomFieldSearcher cfs = null;
308 if (ObjectUtils.isValueSelected(_fieldSearcher)) {
309 cfs = customFieldManager.getCustomFieldSearcher(_fieldSearcher);
310 } else {
311 cfs = null;
312 }
313
314 createdCustomField = customFieldManager.getCustomFieldObjectByName(_fieldName);
315 if (createdCustomField == null) {
316 try {
317 final CustomFieldType customFieldType = customFieldManager.getCustomFieldType(_fieldType);
318
319
320 List contexts = CustomFieldUtils.buildJiraIssueContexts(true, categories, projects, treeManager);
321
322 List returnIssueTypes = FieldConfigSchemeManager.ALL_ISSUE_TYPES;
323 createdCustomField = customFieldManager.createCustomField(_fieldName, _fieldDescription, customFieldType, cfs, contexts, returnIssueTypes);
324
325 } finally {
326 }
327
328 log.info("...... CustomField [" + _fieldName + "] added.");
329 } else {
330 createdCustomField.setDescription(_fieldDescription);
331 createdCustomField.setCustomFieldSearcher(cfs);
332 createdCustomField.store();
333 if (_updateCFType) {
334 Long idCustomField = createdCustomField.getIdAsLong();
335 UpgradeHelper.setCustomFieldType(idCustomField.toString(), CustomFieldImpl.ENTITY_CF_TYPE_KEY, _fieldType);
336 customFieldManager.refresh();
337 createdCustomField = customFieldManager.getCustomFieldObject(idCustomField);
338 }
339 log.info("...... CustomField [" + _fieldName + "] updated.");
340 }
341
342 return createdCustomField;
343 }
344
345 public FieldConfig getDefaultFieldConfig(final CustomField _customField, IssueContext _issueContext) {
346 return _customField.getRelevantConfig(_issueContext);
347 }
348
349 public Option addSelectValue(FieldConfig _fieldConfig, String _value) {
350 return addSelectValue(_fieldConfig, _value, false);
351 }
352
353 public Option addSelectValue(FieldConfig _fieldConfig, String _value, boolean isDefaultValue) {
354 return addSelectValue(_fieldConfig, null, _value, isDefaultValue);
355 }
356
357 public Option addSelectValue(FieldConfig _fieldConfig, Option _parentOption, String _value) {
358 return addSelectValue(_fieldConfig, _parentOption, _value, false);
359 }
360
361 public Option addSelectValue(FieldConfig _fieldConfig, Option _parentOption, String _value, boolean isDefaultValue) {
362 Option newOption = null;
363 Long parentOptionId = (_parentOption != null) ? _parentOption.getOptionId() : null;
364
365 if (_fieldConfig != null) {
366 Options ops = optionsManager.getOptions(_fieldConfig);
367 newOption = ops.getOptionForValue(_value, parentOptionId);
368 if (newOption == null) {
369 newOption = ops.addOption(_parentOption, _value);
370 }
371 if (isDefaultValue) {
372 setDefaultValue(_fieldConfig, newOption);
373 }
374 }
375 return newOption;
376 }
377
378 public void setDefaultValue(FieldConfig _fieldConfig, Option _option) {
379 CustomField cf = _fieldConfig.getCustomField();
380 CustomFieldType cft = cf.getCustomFieldType();
381 if (cft instanceof CascadingSelectCFType) {
382 final CustomFieldParamsImpl customFieldParams = new CustomFieldParamsImpl(cf);
383 Map map = new HashMap();
384
385 String[] pop = { _option.getParentOption().getOptionId().toString() };
386 String[] op = { _option.getOptionId().toString() };
387
388 customFieldParams.addValue(null, Arrays.asList(pop));
389 customFieldParams.addValue("1", Arrays.asList(op));
390
391 map.put(cf.getId(), customFieldParams);
392 final Object customFieldDefault = cf.getValueFromParams(map);
393 cft.setDefaultValue(_fieldConfig, customFieldDefault);
394 } else if (cft instanceof SelectCFType) {
395 cft.setDefaultValue(_fieldConfig, _option.getValue());
396 } else if (cft instanceof MultipleSettableCustomFieldType) {
397 ArrayList defaultValues = new ArrayList();
398 defaultValues.add(_option.getValue());
399 cft.setDefaultValue(_fieldConfig, defaultValues);
400 } else {
401 cft.setDefaultValue(_fieldConfig, _option.getValue());
402 }
403 }
404
405 public Option addChildOption(Option _option, int _seq, String _value) {
406 Option newOption = null;
407 if (_option != null) {
408 newOption = optionsManager.createOption(_option.getRelatedCustomField(), _option.getOptionId(), new Long(_seq), _value);
409 }
410 return newOption;
411 }
412
413 public String getIssueTypeId(String _issueType) {
414 String issueTypeId = null;
415 if (_issueType != null) {
416 List issueTypes = constantsManager.getAllIssueTypes();
417 for (Iterator iterator = issueTypes.iterator(); iterator.hasNext();) {
418 GenericValue issueType = (GenericValue) iterator.next();
419 if (_issueType.equals(issueType.getString("name"))) {
420 issueTypeId = issueType.getString("id");
421 }
422 }
423 }
424
425 return issueTypeId;
426 }
427
428 public Long getProject(String _projectKey) {
429 Long project = null;
430 if (_projectKey != null) {
431 GenericValue projectGv = projectManager.getProjectByKey(_projectKey);
432 if (projectGv != null) {
433 project = projectGv.getLong("id");
434 }
435 }
436
437 return project;
438 }
439
440
441
442
443
444
445
446
447 public void addEventType(final int _id, final String _name, final int _templateId) {
448 EventType eventType = new EventType(new Long(_id), _name, _name, new Long(_templateId));
449 if (eventTypeManager.isEventTypeExists(new Long(_id))) {
450 eventTypeManager.deleteEventType(new Long(_id));
451 }
452 eventTypeManager.addEventType(eventType);
453 }
454
455
456
457
458
459
460
461
462 public void addEventType(final int _id, final String _name, final String _description, final int _templateId) {
463 EventType eventType = new EventType(new Long(_id), _name, _description, new Long(_templateId));
464 if (eventTypeManager.isEventTypeExists(new Long(_id))) {
465 eventTypeManager.deleteEventType(new Long(_id));
466 }
467 eventTypeManager.addEventType(eventType);
468 }
469
470 public void setTemplateIdToEventType(final Long _id, final int _templateId) {
471 if (eventTypeManager.isEventTypeExists(_id)) {
472 EventType eventType = eventTypeManager.getEventType(_id);
473 eventTypeManager.editEventType(eventType.getId(), eventType.getName(), eventType.getDescription(), new Long(_templateId));
474 }
475 }
476
477
478
479
480
481
482
483 public Long getEventTypeId(final String _name) {
484 for (Iterator it = eventTypeManager.getEventTypes().iterator(); it.hasNext();) {
485 EventType eventType = (EventType) it.next();
486 if (_name.equals(eventType.getName())) {
487 return eventType.getId();
488 }
489 }
490 return null;
491 }
492
493 }