コード例 #1
0
  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);
  }
コード例 #2
0
 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());
     }
   }
 }
コード例 #3
0
  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();
  }
コード例 #4
0
  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);
        }
      }
    }
  }
コード例 #5
0
  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);
      }
    }
  }
コード例 #6
0
  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);
      }
    }
  }