Examples with HierarchicalPersistent com.ramussoft.core.attribute.simple.HierarchicalPersistent used on opensource projects

Example 6 with HierarchicalPersistent

use of com.ramussoft.core.attribute.simple.HierarchicalPersistent in project ramus by Vitaliy-Yakovchuk.

the class TableTabView method convertFirstLevelToQualifiers.

public void convertFirstLevelToQualifiers() {
    Qualifier qq = StandardAttributesPlugin.getQualifiersQualifier(engine);
    HierarchicalPersistent hp = new HierarchicalPersistent();
    Element element = StandardAttributesPlugin.getElement(engine, getQualifier().getId());
    hp.setParentElementId(element.getId());
    hp.setPreviousElementId(-1l);
    Attribute hAttribute = StandardAttributesPlugin.getHierarchicalAttribute(engine);
    Attribute nameAttribute = StandardAttributesPlugin.getAttributeNameAttribute(engine);
    for (Row row : toArray(component.getRowSet().getRoot().getChildren())) {
        String name = row.getName();
        Row[] children = toArray(row.getChildren());
        engine.setElementQualifier(row.getElementId(), qq.getId());
        row.getElement().setQualifierId(qq.getId());
        engine.setAttribute(row.getElement(), hAttribute, hp);
        engine.setAttribute(row.getElement(), nameAttribute, name);
        hp.setPreviousElementId(row.getElementId());
        Qualifier qualifier = StandardAttributesPlugin.getQualifier(engine, row.getElement());
        for (Attribute attribute : getQualifier().getAttributes()) {
            if (qualifier.getAttributes().indexOf(attribute) < 0)
                qualifier.getAttributes().add(attribute);
        }
        engine.updateQualifier(qualifier);
        for (Row row2 : children) {
            moveRows(row2, qualifier.getId());
            HierarchicalPersistent h = (HierarchicalPersistent) engine.getAttribute(row2.getElement(), hAttribute);
            h.setParentElementId(-1l);
            row2.setAttribute(hAttribute, h);
        }
    }
    Attribute nameAttr = null;
    for (Attribute attribute : qualifier.getAttributes()) if (attribute.getId() == qualifier.getAttributeForName())
        nameAttr = attribute;
    getQualifier().getAttributes().clear();
    if (nameAttr != null)
        getQualifier().getAttributes().add(nameAttr);
    engine.updateQualifier(getQualifier());
}

Example 7 with HierarchicalPersistent

use of com.ramussoft.core.attribute.simple.HierarchicalPersistent in project ramus by Vitaliy-Yakovchuk.

the class QualifierImporterImpl method importQualifiers.

public void importQualifiers(int elementImportType, boolean importTableAttributes) {
    int i = 0;
    for (Qualifier sourceQualifier : sourceQualifiers) {
        Qualifier qualifier = createQualifier(sourceQualifier, sourceRows[i]);
        qualifiers.put(sourceQualifier, qualifier);
        i++;
    }
    if (importTableAttributes)
        createTableAttributes();
    for (Qualifier sourceQualifier : sourceQualifiers) {
        Qualifier qualifier = getDestination(sourceQualifier);
        Attribute attributeForDestName = null;
        for (Attribute sourceAttribute : sourceQualifier.getAttributes()) {
            Attribute destAttribute = getDestination(sourceAttribute);
            if (destAttribute == null) {
                AttributePlugin plugin = framework.findAttributePlugin(sourceAttribute.getAttributeType());
                if (plugin != null) {
                    destAttribute = plugin.createSyncAttribute(engine, this, sourceAttribute);
                    if (destAttribute != null) {
                        attributes.put(sourceAttribute, destAttribute);
                    }
                }
            }
            if (destAttribute != null) {
                if (qualifier.getAttributes().indexOf(destAttribute) < 0) {
                    qualifier.getAttributes().add(destAttribute);
                }
                if (sourceQualifier.getAttributeForName() == sourceAttribute.getId())
                    attributeForDestName = destAttribute;
            }
        }
        if (attributeForDestName != null)
            qualifier.setAttributeForName(attributeForDestName.getId());
        engine.updateQualifier(qualifier);
    }
    for (Qualifier sourceQualifier : sourceQualifiers) {
        for (Attribute sourceAttribute : sourceQualifier.getAttributes()) {
            Attribute destAttribute = getDestination(sourceAttribute);
            if (destAttribute != null) {
                AttributePlugin plugin = framework.findAttributePlugin(sourceAttribute.getAttributeType());
                if (plugin != null) {
                    plugin.syncAttribute(engine, this, sourceAttribute);
                }
            }
        }
    }
    for (Qualifier sourceQualifier : sourceQualifiers) {
        Qualifier qualifier = getDestination(sourceQualifier);
        List<Element> sourceElements = source.getElements(sourceQualifier.getId());
        List<Element> destElements = engine.getElements(qualifier.getId());
        for (Element sourceElement : sourceElements) {
            Element dest = createElement(sourceElement, destElements, qualifier.getId());
            elements.put(sourceElement, dest);
        }
    }
    if (importTableAttributes)
        setupTableElements();
    Attribute hAttribute = StandardAttributesPlugin.getHierarchicalAttribute(source);
    for (Qualifier sourceQualifier : sourceQualifiers) {
        List<Element> sourceElements = source.getElements(sourceQualifier.getId());
        boolean h = sourceQualifier.getSystemAttributes().indexOf(hAttribute) >= 0;
        for (Element sourceElement : sourceElements) {
            Element dest = getDestination(sourceElement);
            if (h && (createdElemets.get(sourceElement) != null)) {
                HierarchicalPersistent hp = (HierarchicalPersistent) getSourceValue(sourceElement, hAttribute);
                Element prev = source.getElement(hp.getPreviousElementId());
                Element parent = source.getElement(hp.getParentElementId());
                HierarchicalPersistent set = new HierarchicalPersistent();
                if (prev == null)
                    set.setPreviousElementId(-1l);
                else
                    set.setPreviousElementId(getDestination(prev).getId());
                if (parent == null) {
                    set.setParentElementId(-1l);
                } else {
                    Element destination = getDestination(parent);
                    if (destination != null)
                        set.setParentElementId(destination.getId());
                    else
                        set.setParentElementId(-1l);
                }
                engine.setAttribute(dest, StandardAttributesPlugin.getHierarchicalAttribute(engine), set);
            }
        }
        Attribute[] attributes = sourceQualifier.getAttributes().toArray(new Attribute[sourceQualifier.getAttributes().size()]);
        Arrays.sort(attributes, new Comparator<Attribute>() {

            @Override
            public int compare(Attribute o1, Attribute o2) {
                AttributePlugin plugin1 = framework.findAttributePlugin(o1.getAttributeType());
                AttributePlugin plugin2 = framework.findAttributePlugin(o1.getAttributeType());
                if (plugin1 == null) {
                    if (plugin2 == null)
                        return 0;
                    else
                        return -1;
                }
                if (plugin2 == null)
                    return 1;
                if (plugin1.getSyncPriority() > plugin2.getSyncPriority())
                    return 1;
                if (plugin1.getSyncPriority() < plugin2.getSyncPriority())
                    return -1;
                return 0;
            }
        });
        for (Attribute sourceAttribute : attributes) {
            Attribute destAttribute = getDestination(sourceAttribute);
            if (destAttribute != null) {
                AttributePlugin plugin = framework.findAttributePlugin(destAttribute.getAttributeType());
                for (Element sourceElement : sourceElements) {
                    if ((createdElemets.get(sourceElement) != null) || (elementImportType == ELEMENT_IMPORT_TYPE_UPDATE)) {
                        if (plugin != null)
                            plugin.syncElement(engine, this, sourceElement, sourceAttribute);
                    }
                }
            }
        }
    }
}

Example 8 with HierarchicalPersistent

use of com.ramussoft.core.attribute.simple.HierarchicalPersistent in project ramus by Vitaliy-Yakovchuk.

the class NewProjectDialog method showModal.

public void showModal(final Engine engine, final AccessRules accessRules, final GUIFramework framework) {
    ((Journaled) engine).setNoUndoPoint();
    final Properties name_author = new DefaultProperties(new Property[] { new DefaultProperty(AUTOR, Property.TEXT_FIELD), new DefaultProperty(PROJECT_NAME, Property.TEXT_FIELD), new DefaultProperty(MODEL_NAME, Property.TEXT_FIELD) }, Factory.getString("name_author.Describe"));
    final Properties used_at = new DefaultProperties(new Property[] { new DefaultProperty(USED_AT, Property.TEXT_FIELD) }, Factory.getString("used_at.Describe"));
    final Properties def = new DefaultProperties(new Property[] { new DefaultProperty(DEFINITION, Property.TEXT) }, Factory.getString("describe.Describe"));
    final Properties clasificators = new DefaultProperties(new Property[] { new DefaultProperty(CLASIFICATOR1, Property.TEXT_FIELD), new DefaultProperty(CLASIFICATOR2, Property.TEXT_FIELD), new DefaultProperty(CLASIFICATOR3, Property.TEXT_FIELD), new DefaultProperty(CLASIFICATOR4, Property.TEXT_FIELD), new DefaultProperty(CLASIFICATOR5, Property.TEXT_FIELD) }, Factory.getString("Clasificators.Describe"));
    masterModel = new DefaultMasterModel(new Properties[] { name_author, used_at, def, clasificators });
    mainPanel = new MainPanel(new PanelCreator(masterModel)) {

        @Override
        public boolean cancel() {
            if (super.cancel()) {
                NewProjectDialog.this.setVisible(false);
                finish();
                return true;
            }
            return false;
        }

        @Override
        protected void finish() {
            super.finish();
            ((Journaled) engine).startUserTransaction();
            final Qualifier baseFunction = engine.createQualifier();
            String modelName = getValue(MODEL_NAME);
            if ((modelName == null) || (modelName.length() == 0))
                baseFunction.setName(ResourceLoader.getString("base_function"));
            else
                baseFunction.setName(modelName);
            Attribute name = engine.createAttribute(new AttributeType("Core", "Text", true));
            name.setName(ResourceLoader.getString("name"));
            engine.updateAttribute(name);
            java.util.Properties ps = engine.getProperties(AutochangePlugin.AUTO_ADD_ATTRIBUTES);
            ps.setProperty(AutochangePlugin.AUTO_ADD_ATTRIBUTE_IDS, Long.toString(name.getId()));
            ps.setProperty(AutochangePlugin.ATTRIBUTE_FOR_NAME, Long.toString(name.getId()));
            engine.setProperties(AutochangePlugin.AUTO_ADD_ATTRIBUTES, ps);
            baseFunction.getAttributes().add(name);
            baseFunction.setAttributeForName(name.getId());
            IDEF0Plugin.installFunctionAttributes(baseFunction, engine);
            Element element = engine.createElement(IDEF0Plugin.getModelTree(engine).getId());
            engine.setAttribute(element, StandardAttributesPlugin.getAttributeQualifierId(engine), baseFunction.getId());
            HierarchicalPersistent hp = new HierarchicalPersistent();
            hp.setParentElementId(-1l);
            hp.setPreviousElementId(-1l);
            engine.setAttribute(element, StandardAttributesPlugin.getAttributeNameAttribute(engine), baseFunction.getName());
            engine.setAttribute(element, StandardAttributesPlugin.getHierarchicalAttribute(engine), hp);
            DataPlugin dataPlugin = NDataPluginFactory.getDataPlugin(baseFunction, engine, accessRules);
            if (dfd.isSelected())
                dataPlugin.getBaseFunction().setDecompositionType(MovingArea.DIAGRAM_TYPE_DFD);
            else if (dfds.isSelected())
                dataPlugin.getBaseFunction().setDecompositionType(MovingArea.DIAGRAM_TYPE_DFDS);
            else if (dfds.isSelected())
                dataPlugin.getBaseFunction().setDecompositionType(MovingArea.DIAGRAM_TYPE_DFDS);
            ProjectOptions projectOptions = new ProjectOptions();
            projectOptions.setProjectAutor(getValue(AUTOR));
            projectOptions.setProjectName(getValue(PROJECT_NAME));
            projectOptions.setDefinition(getValue(DEFINITION));
            projectOptions.setUsedAt(getValue(USED_AT));
            NewProjectDialog.this.setVisible(false);
            final String[] cls = getClasifiactors();
            final StringBuffer ounersIds = new StringBuffer();
            for (final String c : cls) {
                Row row = dataPlugin.createRow(null, false);
                Qualifier qualifier = engine.getQualifier(StandardAttributesPlugin.getQualifierId(engine, row.getElement().getId()));
                qualifier.setName(c);
                engine.updateQualifier(qualifier);
                if (ouners.indexOf(c) >= 0) {
                    ounersIds.append(qualifier.getId());
                    ounersIds.append(' ');
                }
            }
            dataPlugin.setProperty(DataPlugin.PROPERTY_OUNERS, ounersIds.toString());
            dataPlugin.getBaseFunction().setProjectOptions(projectOptions);
            ((Journaled) engine).commitUserTransaction();
            ((Journaled) engine).setNoUndoPoint();
            SwingUtilities.invokeLater(new Runnable() {

                @Override
                public void run() {
                    framework.propertyChanged("ShowWorkspace", "Workspace.IDEF0");
                    OpenDiagram open = new OpenDiagram(baseFunction, -1l);
                    framework.propertyChanged(IDEF0ViewPlugin.OPEN_DIAGRAM, open);
                }
            });
        }
    };
    setContentPane(mainPanel);
    pack();
    Dimension size = this.getSize();
    setMinimumSize(new Dimension(size.width, size.height + 30));
    setLocationRelativeTo(null);
    setVisible(true);
    frame.repaint();
}

Example 9 with HierarchicalPersistent

use of com.ramussoft.core.attribute.simple.HierarchicalPersistent in project ramus by Vitaliy-Yakovchuk.

the class StandardAttributesPlugin method init.

@SuppressWarnings("deprecation")
@Override
public void init(final Engine engine, final AccessRules accessor) {
    super.init(engine, accessor);
    engine.setPluginProperty(getName(), STANDARD_ATTRIBUTES_PLUGIN, this);
    if ((attributes != null) || (qualifiers != null)) {
        throw new RuntimeException("Plugin has already been inted");
    }
    qualifiers = engine.getSystemQualifier(QUALIFIERS_QUALIFIER);
    attributes = engine.getSystemQualifier(ATTRIBUTES_QUALIFIER);
    iconsQualifier = engine.getSystemQualifier(ICONS_QUALIFIER);
    historyQualifier = engine.getSystemQualifier(QUALIFIER_HISTORY);
    if (historyQualifier == null) {
        historyQualifier = engine.createSystemQualifier();
        historyQualifier.setName(QUALIFIER_HISTORY);
        historyElement = engine.createSystemAttribute(new AttributeType("Core", "Long", true));
        historyElement.setName(ATTRIBUTE_HISTORY_ELEMENT);
        engine.updateAttribute(historyElement);
        historyAttribute = engine.createSystemAttribute(new AttributeType("Core", "Long", true));
        historyAttribute.setName(ATTRIBUTE_HISTORY_ATTRIBUTE);
        engine.updateAttribute(historyAttribute);
        historyTime = engine.createSystemAttribute(new AttributeType("Core", "Date", true));
        historyTime.setName(ATTRIBUTE_HISTORY_TIME);
        engine.updateAttribute(historyTime);
        historyQualifier.getSystemAttributes().add(historyElement);
        historyQualifier.getSystemAttributes().add(historyAttribute);
        historyQualifier.getSystemAttributes().add(historyTime);
        engine.updateQualifier(historyQualifier);
    } else {
        historyElement = engine.getSystemAttribute(ATTRIBUTE_HISTORY_ELEMENT);
        historyAttribute = engine.getSystemAttribute(ATTRIBUTE_HISTORY_ATTRIBUTE);
        historyTime = engine.getSystemAttribute(ATTRIBUTE_HISTORY_TIME);
    }
    for (Qualifier qualifier : engine.getSystemQualifiers()) {
        if (qualifier.getName().startsWith(TABLE_QUALIFIER))
            tableQualifierIds.add(qualifier.getId());
    }
    if (((qualifiers == null) && (attributes != null)) || ((qualifiers != null) && (attributes == null))) {
        throw new RuntimeException("Attributes and qualifiers must inited both in the same time.");
    }
    if (qualifiers == null) {
        initQualifiers(engine);
    } else {
        loadAttributes();
    }
    iconsAttribute = engine.getSystemAttribute(ICONS_ATTRIBUTE);
    iconsQualifierLeafs = engine.getSystemAttribute(ICONS_QUALIFIER_LEAFS);
    iconsQualifierOpenFolders = engine.getSystemAttribute(ICONS_QUALIFIER_OPEN_FOLDERS);
    iconsQualifierClosedFolders = engine.getSystemAttribute(ICONS_QUALIFIER_CLOSED_FOLDERS);
    tableElementIdAttribute = engine.getSystemAttribute(TABLE_ELEMENT_ID_ATTRIBUTE);
    if (iconsQualifier == null) {
        createIconsQualifier(engine);
    }
    if (tableElementIdAttribute == null) {
        createTableElementIdAttribute(engine);
    }
    engine.setPluginProperty(getName(), ATTRIBUTES_QUALIFIER, attributes);
    engine.setPluginProperty(getName(), QUALIFIERS_QUALIFIER, qualifiers);
    engine.setPluginProperty(getName(), ATTRIBUTE_NAME, nameAttribute);
    engine.setPluginProperty(getName(), QUALIFIER_ID, aQualifierId);
    engine.setPluginProperty(getName(), ATTRIBUTE_TYPE_NAME, attributeTypeName);
    engine.setPluginProperty(getName(), ATTRIBUTE_ID, aAttributeId);
    engine.setPluginProperty(getName(), QUALIFIER_ATTRIBUTES, aList);
    engine.setPluginProperty(getName(), ICONS_QUALIFIER, iconsQualifier);
    engine.setPluginProperty(getName(), ICONS_ATTRIBUTE, iconsAttribute);
    engine.setPluginProperty(getName(), ICONS_QUALIFIER_LEAFS, iconsQualifierLeafs);
    engine.setPluginProperty(getName(), ICONS_QUALIFIER_OPEN_FOLDERS, iconsQualifierOpenFolders);
    engine.setPluginProperty(getName(), ICONS_QUALIFIER_CLOSED_FOLDERS, iconsQualifierClosedFolders);
    engine.addQualifierListener(new QualifierAdapter() {

        @Override
        public void qualifierCreated(QualifierEvent event) {
            if (!autocreateFromQualifiers)
                return;
            if (disableAutoupdate)
                return;
            if (event.isJournaled())
                return;
            synchronized (threadLocker) {
                if (Thread.currentThread() == currentThread)
                    return;
            }
            try {
                synchronized (threadLocker) {
                    currentThread = Thread.currentThread();
                }
                Engine e = event.getEngine();
                Element element = e.createElement(qualifiers.getId());
                e.setAttribute(element, aQualifierId, event.getNewQualifier().getId());
                e.setAttribute(element, nameAttribute, "");
            } finally {
                synchronized (threadLocker) {
                    currentThread = null;
                }
            }
        }

        @Override
        public void qualifierDeleted(QualifierEvent event) {
            Qualifier qualifier = event.getOldQualifier();
            if ((qualifier.isSystem()) && (qualifier.getName().startsWith(TABLE_QUALIFIER))) {
                tableQualifierIds.remove(new Long(qualifier.getId()));
            }
            if (event.isJournaled())
                return;
            if (disableAutoupdate)
                return;
            synchronized (threadLocker) {
                if (Thread.currentThread() == currentThread)
                    return;
            }
            try {
                synchronized (threadLocker) {
                    currentThread = Thread.currentThread();
                }
                Engine e = event.getEngine();
                List<Element> elements = e.findElements(qualifiers.getId(), aQualifierId, event.getOldQualifier().getId());
                if (elements.size() != 1) {
                    return;
                }
                e.deleteElement(elements.get(0).getId());
            } finally {
                synchronized (threadLocker) {
                    currentThread = null;
                }
            }
        }

        @Override
        public void qualifierUpdated(QualifierEvent event) {
            Qualifier qualifier = event.getNewQualifier();
            if ((qualifier.isSystem()) && (qualifier.getName().startsWith(TABLE_QUALIFIER)))
                tableQualifierIds.add(qualifier.getId());
            if (event.isJournaled())
                return;
            if (disableAutoupdate)
                return;
            List<Attribute> attributesToRemove = getAttributesToRemove(event);
            List<Element> allElements = null;
            for (Attribute attribute : attributesToRemove) {
                if (attribute.getAttributeType().toString().equals("Core.Table")) {
                    if (allElements == null) {
                        allElements = engine.getElements(event.getNewQualifier().getId());
                    }
                    for (Element element : allElements) {
                        for (Element element2 : getTableElements(engine, attribute, element)) {
                            engine.deleteElement(element2.getId());
                        }
                    }
                }
            }
            if (event.getNewQualifier().isSystem())
                return;
            synchronized (threadLocker) {
                if (Thread.currentThread() == currentThread)
                    return;
            }
            try {
                synchronized (threadLocker) {
                    currentThread = Thread.currentThread();
                }
                Engine e = event.getEngine();
                List<Element> elements = e.findElements(qualifiers.getId(), aQualifierId, event.getNewQualifier().getId());
                if (elements.size() != 1) {
                    // .println("Not regidtered qualifier was updated, or data integrity wrong.");
                    return;
                }
                e.setAttribute(elements.get(0), nameAttribute, event.getNewQualifier().getName());
                List<Attribute> list = event.getNewQualifier().getAttributes();
                List<ElementListPersistent> pList = new ArrayList<ElementListPersistent>();
                for (Attribute a : list) {
                    if (isSystem(a.getAttributeType()))
                        continue;
                    List<Element> ems = e.findElements(attributes.getId(), aAttributeId, a.getId());
                    if (ems.size() != 1) {
                        throw new RuntimeException("Fatal error, not registered attribute was removed, or data integrity wrong.");
                    }
                    pList.add(new ElementListPersistent(elements.get(0).getId(), ems.get(0).getId()));
                }
                e.setAttribute(elements.get(0), aList, pList);
            } finally {
                synchronized (threadLocker) {
                    currentThread = null;
                }
            }
        }

        private List<Attribute> getAttributesToRemove(QualifierEvent event) {
            List<Attribute> res = new ArrayList<Attribute>(0);
            diff(event.getOldQualifier().getAttributes(), event.getNewQualifier().getAttributes(), res);
            diff(event.getOldQualifier().getSystemAttributes(), event.getNewQualifier().getSystemAttributes(), res);
            return res;
        }

        private void diff(List<Attribute> attributes, List<Attribute> attributes2, List<Attribute> res) {
            for (Attribute attribute : attributes) if (attributes2.indexOf(attribute) < 0) {
                res.add(attribute);
            }
        }
    });
    engine.addAttributeListener(new AttributeAdapter() {

        @Override
        public void attributeCreated(AttributeEvent event) {
            if (event.isJournaled())
                return;
            if (disableAutoupdate)
                return;
            if (isSystem(event.getAttribute().getAttributeType()))
                return;
            synchronized (threadLocker) {
                if (Thread.currentThread() == currentThread)
                    return;
            }
            try {
                synchronized (threadLocker) {
                    currentThread = Thread.currentThread();
                }
                long lastId = getLastId();
                HierarchicalPersistent hp = new HierarchicalPersistent();
                hp.setIconId(-1l);
                hp.setParentElementId(-1l);
                hp.setPreviousElementId(lastId);
                Engine e = event.getEngine();
                Element element = e.createElement(attributes.getId());
                e.setAttribute(element, aAttributeId, event.getAttribute().getId());
                e.setAttribute(element, getHierarchicalAttribute(engine), hp);
                e.setAttribute(element, nameAttribute, "");
                e.setAttribute(element, attributeTypeName, event.getAttribute().getAttributeType().toString());
            } finally {
                synchronized (threadLocker) {
                    currentThread = null;
                }
            }
        }

        private long getLastId() {
            try {
                if (engine.getDeligate() instanceof IEngineImpl) {
                    IEngineImpl impl = ((IEngineImpl) engine.getDeligate());
                    String prefix = impl.getPrefix();
                    String sql = "SELECT element_id FROM " + prefix + "elements WHERE element_id NOT IN (SELECT previous_element_id FROM " + prefix + "attribute_hierarchicals) AND qualifier_id=?";
                    JDBCTemplate template = impl.getTemplate();
                    Object res = template.queryForObject(sql, new RowMapper() {

                        @Override
                        public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
                            return rs.getLong(1);
                        }
                    }, attributes.getId(), true);
                    if (res != null)
                        return ((Long) res).longValue();
                    return -1l;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            List<Attribute> attrs = new ArrayList<Attribute>();
            attrs.add(getHierarchicalAttribute(engine));
            Hashtable<Element, Object[]> hash = engine.getElements(attributes, attrs);
            Element element = null;
            for (Element e1 : hash.keySet()) {
                element = e1;
                for (Object[] objects : hash.values()) {
                    HierarchicalPersistent hp = (HierarchicalPersistent) objects[0];
                    if (hp != null) {
                        if (hp.getPreviousElementId() == element.getId()) {
                            element = null;
                            break;
                        }
                    }
                }
                if (element != null)
                    break;
            }
            if (element == null)
                return -1l;
            return element.getId();
        }

        @Override
        public void attributeDeleted(AttributeEvent event) {
            if (event.isJournaled())
                return;
            if (disableAutoupdate)
                return;
            if (((Attribute) event.getOldValue()).getAttributeType().toString().equals("Core.Table")) {
                Qualifier qualifier = getTableQualifierForAttribute(engine, (Attribute) event.getOldValue());
                engine.deleteQualifier(qualifier.getId());
            }
            if (isSystem(((Attribute) event.getOldValue()).getAttributeType()))
                return;
            synchronized (threadLocker) {
                if (Thread.currentThread() == currentThread)
                    return;
            }
            try {
                synchronized (threadLocker) {
                    currentThread = Thread.currentThread();
                }
                Engine e = event.getEngine();
                List<Element> elements = e.findElements(attributes.getId(), aAttributeId, event.getAttribute().getId());
                if (elements.size() != 1) {
                    throw new RuntimeException("Fatal error, not registered qualifier was removed, or data integrity wrong.");
                }
                e.deleteElement(elements.get(0).getId());
            } finally {
                synchronized (threadLocker) {
                    currentThread = null;
                }
            }
        }

        @Override
        public void attributeUpdated(AttributeEvent event) {
            if (event.isJournaled())
                return;
            if (disableAutoupdate)
                return;
            if (isSystem(event.getAttribute().getAttributeType()))
                return;
            synchronized (threadLocker) {
                if (Thread.currentThread() == currentThread)
                    return;
            }
            try {
                synchronized (threadLocker) {
                    currentThread = Thread.currentThread();
                }
                Engine e = event.getEngine();
                List<Element> elements = e.findElements(attributes.getId(), aAttributeId, event.getAttribute().getId());
                if (elements.size() != 1) {
                    return;
                // throw new RuntimeException(
                // "Fatal error, not registered attribute was removed, or data integrity wrong.");
                }
                e.setAttribute(elements.get(0), nameAttribute, event.getAttribute().getName());
            } finally {
                synchronized (threadLocker) {
                    currentThread = null;
                }
            }
        }

        @Override
        public void beforeAttributeDeleted(AttributeEvent event) {
            if (event.isJournaled())
                return;
            if (disableAutoupdate)
                return;
            Attribute attribute = event.getAttribute();
            Engine engine = event.getEngine();
            if (attribute.getAttributeType().toString().equals("Core.Table")) {
                Qualifier qualifier = getTableQualifierForAttribute(engine, attribute);
                if (qualifier != null) {
                    for (Element element : engine.getElements(qualifier.getId())) {
                        engine.deleteElement(element.getId());
                    }
                }
            }
        }
    });
    engine.addElementAttributeListener(qualifiers, new ElementAttributeListener() {

        @SuppressWarnings("unchecked")
        @Override
        public void attributeChanged(AttributeEvent event) {
            if (event.isJournaled())
                return;
            if (disableAutoupdate)
                return;
            if (event.getAttribute().equals(aQualifierId)) {
                Engine e = event.getEngine();
                Qualifier q = e.getQualifier((Long) event.getNewValue());
                List<Element> elements = e.findElements(qualifiers.getId(), aQualifierId, q.getId());
                if (elements.size() != 1) {
                    // .println("Not regidtered qualifier was updated, or data integrity wrong.");
                    return;
                }
                List<Attribute> list = q.getAttributes();
                List<ElementListPersistent> pList = new ArrayList<ElementListPersistent>();
                for (Attribute a : list) {
                    List<Element> ems = e.findElements(attributes.getId(), aAttributeId, a.getId());
                    if (ems.size() != 1) {
                        throw new RuntimeException("Fatal error, not registered attribute was removed, or data integrity wrong.");
                    }
                    pList.add(new ElementListPersistent(elements.get(0).getId(), ems.get(0).getId()));
                }
                Element element = elements.get(0);
                element.setQualifierId(qualifiers.getId());
                e.setAttribute(element, aList, pList);
            }
            synchronized (threadLocker) {
                if (Thread.currentThread() == currentThread)
                    return;
            }
            Engine e = event.getEngine();
            try {
                synchronized (threadLocker) {
                    currentThread = Thread.currentThread();
                }
                if (event.getAttribute().equals(nameAttribute)) {
                    Qualifier qualifier = e.getQualifier((Long) e.getAttribute(event.getElement(), aQualifierId));
                    qualifier.setName((String) event.getNewValue());
                    e.updateQualifier(qualifier);
                } else if (event.getAttribute().equals(aList)) {
                    Long attribute = (Long) e.getAttribute(event.getElement(), aQualifierId);
                    if (attribute == null)
                        return;
                    Qualifier qualifier = e.getQualifier(attribute);
                    List<ElementListPersistent> list = (List<ElementListPersistent>) e.getAttribute(event.getElement(), aList);
                    List<Attribute> attrs = new ArrayList<Attribute>();
                    for (ElementListPersistent p : list) {
                        Element attr = e.getElement(p.getElement2Id());
                        Attribute a = e.getAttribute(((Long) e.getAttribute(attr, aAttributeId)));
                        attrs.add(a);
                    }
                    List<Attribute> al = qualifier.getAttributes();
                    for (int i = al.size() - 1; i >= 0; i--) {
                        if (attrs.indexOf(al.get(i)) < 0) {
                            al.remove(i);
                        }
                    }
                    for (Attribute a : attrs) {
                        if (al.indexOf(a) < 0)
                            al.add(a);
                    }
                    e.updateQualifier(qualifier);
                }
            } finally {
                synchronized (threadLocker) {
                    currentThread = null;
                }
            }
        }
    });
    engine.addElementAttributeListener(attributes, new ElementAttributeListener() {

        @Override
        public void attributeChanged(AttributeEvent event) {
            if (event.isJournaled())
                return;
            if (disableAutoupdate)
                return;
            synchronized (threadLocker) {
                if (Thread.currentThread() == currentThread)
                    return;
            }
            Engine e = event.getEngine();
            try {
                synchronized (threadLocker) {
                    currentThread = Thread.currentThread();
                }
                if (event.getAttribute().equals(nameAttribute)) {
                    Attribute attribute = e.getAttribute((Long) e.getAttribute(event.getElement(), aAttributeId));
                    attribute.setName((String) event.getNewValue());
                    e.updateAttribute(attribute);
                }
            } finally {
                synchronized (threadLocker) {
                    currentThread = null;
                }
            }
        }
    });
    engine.addElementAttributeListener(null, new ElementAttributeListener() {

        @Override
        public void attributeChanged(AttributeEvent event) {
            if (disableAutoupdate)
                return;
            Element element = event.getElement();
            if (element == null)
                return;
            try {
                if (tableQualifierIds.indexOf(new Long(element.getQualifierId())) >= 0) {
                    Object parentElementId;
                    if (event.getAttribute().equals(tableElementIdAttribute))
                        parentElementId = event.getNewValue();
                    else
                        parentElementId = engine.getAttribute(element, tableElementIdAttribute);
                    if (parentElementId != null) {
                        Qualifier table = engine.getQualifier(element.getQualifierId());
                        Attribute attribute = getAttributeForTable(engine, table);
                        Element parent = engine.getElement((Long) parentElementId);
                        AttributeEvent event2 = new AttributeEvent(engine, parent, attribute, null, null, event.isJournaled());
                        for (ElementAttributeListener listener : engine.getElementAttributeListeners(-1)) listener.attributeChanged(event2);
                        for (ElementAttributeListener listener : engine.getElementAttributeListeners(parent.getQualifierId())) listener.attributeChanged(event2);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            if (event.isJournaled())
                return;
            List<Long> attrs = historyQualifiers.get(element.getQualifierId());
            if (attrs != null)
                if (attrs.indexOf(event.getAttribute().getId()) >= 0) {
                    Element data = engine.createElement(historyQualifier.getId());
                    engine.setAttribute(data, event.getAttribute(), event.getNewValue());
                    engine.setAttribute(data, historyElement, element.getId());
                    engine.setAttribute(data, historyAttribute, event.getAttribute().getId());
                    engine.setAttribute(data, historyTime, new Date());
                }
        }
    });
    engine.addElementListener(qualifiers, new ElementAdapter() {

        @Override
        public void elementCreated(ElementEvent event) {
            if (event.isJournaled())
                return;
            if (disableAutoupdate)
                return;
            synchronized (threadLocker) {
                if (Thread.currentThread() == currentThread)
                    return;
            }
            Engine e = event.getEngine();
            try {
                synchronized (threadLocker) {
                    currentThread = Thread.currentThread();
                }
                Qualifier qualifier = e.createQualifier();
                e.setAttribute(event.getNewElement(), aQualifierId, qualifier.getId());
            } finally {
                synchronized (threadLocker) {
                    currentThread = null;
                }
            }
        }

        @Override
        public void beforeElementDeleted(ElementEvent event) {
            if (event.isJournaled())
                return;
            if (disableAutoupdate)
                return;
            synchronized (threadLocker) {
                if (Thread.currentThread() == currentThread)
                    return;
            }
            Engine e = event.getEngine();
            long qualifierId = event.getOldElement().getQualifierId();
            if ((qualifierId != qualifiers.getId()) && (qualifierId != attributes.getId()))
                return;
            try {
                synchronized (threadLocker) {
                    currentThread = Thread.currentThread();
                }
                if (qualifierId == qualifiers.getId()) {
                    Object attribute = e.getAttribute(event.getOldElement(), aQualifierId);
                    if (attribute != null)
                        e.deleteQualifier((Long) attribute);
                } else {
                    throw new RuntimeException("Element for attribute can not be deleted");
                }
            } finally {
                synchronized (threadLocker) {
                    currentThread = null;
                }
            }
        }
    });
    engine.addElementListener(null, new ElementAdapter() {

        @Override
        public void beforeElementDeleted(ElementEvent event) {
            if (disableAutoupdate)
                return;
            Element element = event.getOldElement();
            if (element == null)
                return;
            try {
                if (tableQualifierIds.indexOf(new Long(element.getQualifierId())) >= 0) {
                    Object parentElementId;
                    parentElementId = engine.getAttribute(element, tableElementIdAttribute);
                    if (parentElementId != null) {
                        Qualifier table = engine.getQualifier(element.getQualifierId());
                        Attribute attribute = getAttributeForTable(engine, table);
                        Element parent = engine.getElement((Long) parentElementId);
                        AttributeEvent event2 = new AttributeEvent(engine, parent, attribute, null, null, event.isJournaled());
                        for (ElementAttributeListener listener : engine.getElementAttributeListeners(-1)) listener.attributeChanged(event2);
                        for (ElementAttributeListener listener : engine.getElementAttributeListeners(parent.getQualifierId())) listener.attributeChanged(event2);
                    }
                } else {
                    Qualifier qualifier = engine.getQualifier(element.getQualifierId());
                    for (Attribute attribute : qualifier.getAttributes()) {
                        if (attribute.getAttributeType().toString().equals("Core.Table")) {
                            for (Element element2 : getTableElements(engine, attribute, element)) {
                                engine.deleteElement(element2.getId());
                            }
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            List<Long> attrs = historyQualifiers.get(element.getQualifierId());
            if (attrs != null) {
                List<Element> list = engine.findElements(historyQualifier.getId(), historyElement, element.getId());
                for (Element element2 : list) engine.deleteElement(element2.getId());
            }
        }
    });
    engine.addStreamListener(new StreamAdapter() {

        @Override
        public void streamUpdated(StreamEvent event) {
            if (event.isJournaled())
                return;
            String path = event.getPath();
            if (path.equals(PROPERTIES)) {
                loadHistoryQualifiers((!disableAutoupdate) && (!event.isJournaled()));
            }
        }
    });
    loadHistoryQualifiers(false);
}

Example 10 with HierarchicalPersistent

use of com.ramussoft.core.attribute.simple.HierarchicalPersistent in project ramus by Vitaliy-Yakovchuk.

the class StandardAttributesPlugin method createElement.

public static Element createElement(Engine engine, long qualifierId, long parentElementId) {
    Element element = engine.createElement(qualifierId);
    Attribute h = getHierarchicalAttribute(engine);
    HierarchicalPersistent hp = new HierarchicalPersistent();
    hp.setPreviousElementId(-1);
    hp.setParentElementId(parentElementId);
    engine.setAttribute(element, h, hp);
    return element;
}