Examples with QualifierEvent com.ramussoft.common.event.QualifierEvent used on opensource projects

Example 11 with QualifierEvent

use of com.ramussoft.common.event.QualifierEvent in project ramus by Vitaliy-Yakovchuk.

the class CreateQualifierCommand method redo.

@Override
public void redo(IEngine iEngine) {
    Qualifier qualifier;
    if (system)
        qualifier = iEngine.createSystemQualifier(qualifierId);
    else
        qualifier = iEngine.createQualifier(qualifierId);
    QualifierEvent event = new QualifierEvent(engine, null, qualifier, true);
    engine.qualifierCreated(event);
}

Example 12 with QualifierEvent

use of com.ramussoft.common.event.QualifierEvent in project ramus by Vitaliy-Yakovchuk.

the class CreateQualifierCommand method undo.

@Override
public void undo(IEngine iEngine) {
    Qualifier old = iEngine.getQualifier(qualifierId);
    iEngine.deleteQualifier(qualifierId);
    QualifierEvent event = new QualifierEvent(engine, old, null, true);
    engine.qualifierDeleted(event);
}

Example 13 with QualifierEvent

use of com.ramussoft.common.event.QualifierEvent in project ramus by Vitaliy-Yakovchuk.

the class QualifierPlugin method setFramework.

@Override
public void setFramework(final GUIFramework framework) {
    super.setFramework(framework);
    this.engine = framework.getEngine();
    this.accessor = framework.getAccessRules();
    framework.addActionListener(OPEN_QUALIFIER, new ActionListener() {

        @Override
        public void onAction(final ActionEvent event) {
            if (framework.openView(event))
                return;
            final Data data = new Data();
            data.qualifier = (Qualifier) event.getValue();
            if (data.qualifier != null) {
                data.qualifier = engine.getQualifier(data.qualifier.getId());
            }
            if (data.qualifier == null)
                return;
            data.listener = new QualifierAdapter() {

                @Override
                public void qualifierUpdated(QualifierEvent event) {
                    if (event.getNewQualifier().equals(data.qualifier)) {
                        ViewTitleEvent e = new ViewTitleEvent(data.view, event.getNewQualifier().getName());
                        data.view.titleChanged(e);
                    }
                }

                @Override
                public void qualifierDeleted(QualifierEvent event) {
                    if (event.getOldQualifier().equals(data.qualifier)) {
                        data.view.close();
                    }
                }
            };
            engine.addQualifierListener(data.listener);
            data.view = new TableTabView(framework, engine, accessor, data.qualifier) {

                @Override
                public void close() {
                    super.close();
                    engine.removeQualifierListener(data.listener);
                    TabbedEvent tEvent = new TabbedEvent("TabbedTableView", this);
                    tabRemoved(tEvent);
                }

                @Override
                public String getTitle() {
                    return qualifier.getName();
                }

                @Override
                public ActionEvent getOpenAction() {
                    return new ActionEvent(OPEN_QUALIFIER, data.qualifier);
                }
            };
            TabbedEvent tEvent = new TabbedEvent(TabbedTableView.MAIN_TABBED_VIEW, (TabView) data.view);
            tabCreated(tEvent);
        }
    });
    framework.setSystemAttributeName(StandardAttributesPlugin.getAttributeNameAttribute(engine), GlobalResourcesManager.getString("AttributeName"));
    framework.setSystemAttributeName(StandardAttributesPlugin.getAttributeTypeNameAttribute(engine), GlobalResourcesManager.getString("AttributeTypeName"));
}

Example 14 with QualifierEvent

use of com.ramussoft.common.event.QualifierEvent 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 15 with QualifierEvent

use of com.ramussoft.common.event.QualifierEvent in project ramus by Vitaliy-Yakovchuk.

the class AutochangePlugin method init.

@Override
public void init(final Engine engine, AccessRules accessor) {
    super.init(engine, accessor);
    engine.addQualifierListener(new QualifierAdapter() {

        @Override
        public void qualifierCreated(QualifierEvent event) {
            if (event.isJournaled())
                return;
            if (StandardAttributesPlugin.isDisableAutoupdate(engine))
                return;
            Qualifier qualifier = event.getNewQualifier();
            if (!qualifier.isSystem()) {
                Properties ps = engine.getProperties(AUTO_ADD_ATTRIBUTES);
                String ids = ps.getProperty(AUTO_ADD_ATTRIBUTE_IDS);
                String attributeForName = ps.getProperty(ATTRIBUTE_FOR_NAME);
                if (ids == null)
                    ids = "";
                StringTokenizer st = new StringTokenizer(ids, " ,");
                boolean added = false;
                while (st.hasMoreElements()) {
                    String s = st.nextToken();
                    long id = Long.parseLong(s);
                    Attribute attr = engine.getAttribute(id);
                    if (attr != null) {
                        added = true;
                        qualifier.getAttributes().add(attr);
                        if (s.equals(attributeForName))
                            qualifier.setAttributeForName(attr.getId());
                    }
                }
                if (added) {
                    engine.updateQualifier(qualifier);
                }
            }
        }
    });
}