void synchronize_formClass(FormContainer o) {
List<FormElement> allchildren = new ArrayList<FormElement>();
allchildren.addAll(o.getFields());
allchildren.addAll(o.getSearchFields());
allchildren.addAll(o.getDisabled());
addMissing(o, allchildren);
update(o, allchildren);
}
protected void updateFormContainerId(FormContainer formContainer) {
if (formContainer instanceof FormSearch) {
SearchInitialization.initializeFormProperties((FormSearch) formContainer);
updateId(formContainer, formContainer.getId());
} else if (formContainer instanceof ClassReference) {
ClassReference cref = (ClassReference) formContainer;
AbstractClass abstractClass = cref.getReal_class();
if (!abstractClass.getName().equals(formContainer.getId())) {
updateId(formContainer, abstractClass.getName());
}
}
}
public void synchronize(FormCollection fc) throws Exception {
InternalModification.dontMoveToDisabled();
removeInvalide(fc);
EList<FormContainer> forms = fc.getForms();
for (FormContainer formContainer : forms) {
synchronizeFormContainer(formContainer);
}
// add Missing FormClass (new Class in dt model)
if (addNewFormClass) {
// get All Class
Collection<AbstractClass> missing = getAllClassesFromReferedModels(fc);
for (AbstractClass abstractClass : missing) {
if (!(abstractClass instanceof Clazz) ^ !((Clazz) abstractClass).isAbstract()) {
FormContainer formContainer = null;
if (!CommonServices.isNativeModel(abstractClass) || includeAlfrescoNativeClass) {
if (fc instanceof ClassFormCollection) {
formContainer = FormFactory.eINSTANCE.createFormClass();
setFormContainer(abstractClass, formContainer);
formContainer.setId(abstractClass.getName());
formContainer.setLabel(abstractClass.getLabel());
} else if (fc instanceof SearchFormCollection) {
formContainer = FormFactory.eINSTANCE.createFormSearch();
setFormContainer(abstractClass, formContainer);
SearchInitialization.initializeFormProperties((FormSearch) formContainer);
} else if (fc instanceof WorkflowFormCollection) {
formContainer = FormFactory.eINSTANCE.createFormWorkflow();
}
if (headless) {
fc.getForms().add(formContainer);
} else {
cc.append(
AddCommand.create(
domain, fc, FormPackage.eINSTANCE.getFormCollection_Forms(), formContainer));
}
if (formContainer instanceof ClassReference) {
synchronizeFormContainer(formContainer);
}
}
}
}
}
InternalModification.moveToDisabled();
}
void update(FormContainer formContainer, List<FormElement> allchildren) {
// update id
if (updateId) {
updateFormContainerId(formContainer);
}
if (updateLabel) {
updateLabel(
formContainer, ((TitledNamedClassModelElement) formContainer.getRef()).getLabel());
}
for (FormElement formElement : allchildren) {
ModelElement ref = formElement.getRef();
if (ref instanceof NamedModelElement) {
NamedModelElement nme = (NamedModelElement) ref;
String name = nme.getName();
if (updateId && !name.equals(formElement.getId())) {
updateId(formElement, name);
}
if (updateLabel && ref instanceof TitledNamedClassModelElement) {
updateLabel(formContainer, ((TitledNamedClassModelElement) ref).getLabel());
}
}
// check Field subType
if (ref instanceof Attribute) {
Attribute att = (Attribute) ref;
updateAttributeFields(formContainer, formElement, att);
} else if (ref instanceof Association) {
Association ass = (Association) ref;
if (formElement instanceof ModelChoiceField) {
ModelChoiceField mcf = (ModelChoiceField) formElement;
ClassReference cref = (ClassReference) formContainer;
AbstractClass srcClazz = cref.getReal_class();
updateModelChoiceField(srcClazz, ass, mcf);
}
}
}
}
protected void synchronizeMissingAttributes(
FormContainer o,
List<FormElement> children,
AbstractClass real_class,
Set<FormGroup> groups,
String filterNS) {
List<Attribute> allAttributes = real_class.getAllAttributes();
// get FormElement that miss
ArrayList<Attribute> missAtt = new ArrayList<Attribute>();
if (allAttributes != null) {
missAtt.addAll(allAttributes);
}
for (FormElement formElement : children) {
ModelElement ref = formElement.getRef();
if (ref != null && ref instanceof Attribute) {
// linked element is attribute so remove this attribute from the missing list
missAtt.remove(ref);
}
}
EList<FormGroup> allSubGroups = o.getAllSubGroups();
groups.addAll(allSubGroups);
// now we have the attribute missing list
// initialize missing Field
for (Attribute attribute : missAtt) {
// Field or searchField
FormElement fieldForAttribute = null;
if (o instanceof FormSearch) {
fieldForAttribute = SearchInitialization.getSearchFieldForAttribute(attribute);
} else if (o instanceof FormClass || o instanceof FormWorkflow) {
fieldForAttribute = ClassDiagramUtils.getFieldForAttribute(attribute);
} else {
System.out.println("SynchronizeWithClass.synchronizeMissingAttributes() o :" + o);
}
if (WorkflowInitialization.filterFormElement(filterNS, fieldForAttribute)) {
// get where to add the field
FormGroup parent = null;
// mybe a group exist with ref to the attribute container
AbstractClass eContainer = (AbstractClass) attribute.eContainer();
// search for matching group
for (FormGroup formGroup : groups) {
ModelElement ref = formGroup.getRef();
if (ref != null && ref.equals(eContainer)) {
// matching group founded
parent = formGroup;
break;
}
}
if (createMissingGroup && parent == null) {
parent = ClassInitialization.createGroup(eContainer);
groups.add(parent);
addChild(o, parent);
}
if (parent == null) {
parent = o;
}
// add new Field to the parent
addChild(parent, fieldForAttribute);
}
}
}
protected void synchronizeMissingAssociations(
FormContainer o,
List<FormElement> children,
AbstractClass real_class,
Set<FormGroup> groups,
String filterNS) {
List<Association> allAssociations = real_class.getAllSourceAssociations();
// get FormElement that miss
ArrayList<Association> missAtt = new ArrayList<Association>();
if (allAssociations != null) {
missAtt.addAll(allAssociations);
}
for (FormElement formElement : children) {
ModelElement ref = formElement.getRef();
if (ref != null && ref instanceof Association) {
// linked element is attribute so remove this attribute from the missing list
missAtt.remove(ref);
}
}
EList<FormGroup> allSubGroups = o.getAllSubGroups();
groups.addAll(allSubGroups);
// now we have the attribute missing list
// initialize missing Field
for (Association ass : missAtt) {
FormElement fieldForAssociation = null;
if (o instanceof FormClass || o instanceof FormWorkflow) {
fieldForAssociation = ClassDiagramUtils.getModelChoiceFieldForAssociation(ass, real_class);
} else if (o instanceof FormSearch) {
fieldForAssociation =
ClassDiagramUtils.transformAssociationIntoModelChoiceSearchField(ass, real_class);
}
if (WorkflowInitialization.filterFormElement(filterNS, fieldForAssociation)) {
// get where to add the field
FormGroup parent = null;
// mybe a group exist with ref to the attribute container
// search for matching group
for (FormGroup formGroup : groups) {
ModelElement ref = formGroup.getRef();
if (ref instanceof AbstractClass
&& ((AbstractClass) ref).getSourceAssociations().contains(ass)) {
// matching group founded
parent = formGroup;
break;
}
}
if (createMissingGroup && parent == null) {
AbstractClass source = null;
EList<AbstractClass> sources = ass.getSource();
if (sources.size() == 1) {
source = sources.get(0);
} else {
EList<AbstractClass> allLinkedAbstractClass = real_class.getAllLinkedAbstractClass();
boolean contains = allLinkedAbstractClass.contains(sources.get(0));
if (contains) {
source = sources.get(0);
} else {
source = sources.get(1);
}
}
parent = ClassInitialization.createGroup(source);
addChild(o, parent);
}
// add new Field to the parent
if (parent == null) {
parent = o;
}
addChild(parent, fieldForAssociation);
}
}
}