eclipse-ui/src/org/apache/sling/ide/eclipse/ui/views/JcrEditingSupport.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.sling.ide.eclipse.ui.views;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import javax.jcr.PropertyType;

import org.apache.sling.ide.eclipse.core.ServerUtil;
import org.apache.sling.ide.eclipse.ui.nav.model.JcrNode;
import org.apache.sling.ide.eclipse.ui.nav.model.JcrProperty;
import org.apache.sling.ide.eclipse.ui.nav.model.JcrTextPropertyDescriptor;
import org.apache.sling.ide.eclipse.ui.nav.model.ModifiableProperties;
import org.apache.sling.ide.transport.NodeTypeRegistry;
import org.apache.sling.ide.transport.Repository;
import org.apache.sling.ide.transport.RepositoryException;
import org.eclipse.jface.fieldassist.ContentProposalAdapter;
import org.eclipse.jface.fieldassist.SimpleContentProposalProvider;
import org.eclipse.jface.fieldassist.TextContentAdapter;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ComboBoxCellEditor;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.ICellEditorValidator;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.views.properties.IPropertyDescriptor;
import org.eclipse.ui.views.properties.TextPropertyDescriptor;

public class JcrEditingSupport extends EditingSupport {
    
    static enum ColumnId {
        NAME, TYPE, VALUE, MULTIPLE
    }

    private final ColumnId columnId;
    private final TableViewer tableViewer;
    private final JcrPropertiesView view;
    
    private class Field {
        private final Object element;

        Field(Object element) {
            this.element = element;
        }

        public boolean canEdit() {
            IPropertyDescriptor pd = (IPropertyDescriptor) element;
            Map.Entry me = (Entry) pd.getId();
            if (me.getKey().equals("jcr:primaryType")) {
                return columnId==ColumnId.VALUE;
            }
            return true;
        }
        
        public Object getValue() {
            IPropertyDescriptor pd = (IPropertyDescriptor) element;
            JcrNode jcrNode = getNode();
            Map.Entry me = (Entry) pd.getId();
            
            switch(columnId) {
            case NAME: {
                return String.valueOf(me.getKey());
            }
            case TYPE: {
                final int propertyType = getNode().getPropertyType(getPropertyName());
                if (propertyType!=-1) {
                    return PropertyTypeSupport.indexOfPropertyType(propertyType);
                } else {
                    //TODO: otherwise hardcode to STRING
                    return PropertyTypeSupport.indexOfPropertyType(PropertyType.STRING);
                }
            }
            case VALUE: {
                final int propertyType = getNode().getPropertyType(getPropertyName());
                String rawValue = String.valueOf(me.getValue());
                int index = rawValue.indexOf("}");
                if (index!=-1) {
                    rawValue = rawValue.substring(index+1);
                }
                if ((propertyType!=-1) && (propertyType==PropertyType.BOOLEAN)) {
                    try{
                        if (Boolean.parseBoolean(String.valueOf(rawValue))) {
                            return 1;
                        } else {
                            return 0;
                        }
                    } catch(Exception e) {
                        return 0;
                    }
                } else if ((propertyType!=-1) && (propertyType!=PropertyType.STRING)) {
                    return rawValue;
                }
                return String.valueOf(me.getValue());
            }
            case MULTIPLE: {
                boolean isMultiple = getNode().getProperty(getPropertyName()).isMultiple();
                return isMultiple ? 1 : 0;
            }
            default: {
                throw new IllegalStateException("Unknown columnId: "+columnId);
            }
            }
        }
        
        public String getPropertyName() {
            IPropertyDescriptor pd = (IPropertyDescriptor) element;
            Map.Entry me = (Entry) pd.getId();
            return String.valueOf(me.getKey());
        }

        public void setValue(Object element, Object value) {
            if (getValue().equals(value)) {
                // then ignore this
                return;
            }
            JcrTextPropertyDescriptor pd = (JcrTextPropertyDescriptor) element;
            JcrNode jcrNode = getNode();
            Map.Entry me = (Entry) pd.getId();
            
            switch(columnId) {
            case NAME: {
                final String oldKey = String.valueOf(getValue());
                final String newKey = String.valueOf(value);
                pd.setNewPropertyName(newKey);
                Map<String, String> pseudoMap = new HashMap<>();
                final String propertyValue = jcrNode.getProperties().getValue(oldKey);
                pseudoMap.put(newKey, propertyValue);
                final Entry<String, String> mapEntry = pseudoMap.entrySet().iterator().next();
                element = new TextPropertyDescriptor(mapEntry, propertyValue);
                jcrNode.renameProperty(oldKey, newKey);
                break;
            }
            case TYPE: {
                int propertyType = PropertyTypeSupport.propertyTypeOfIndex((Integer)value);
                jcrNode.changePropertyType(String.valueOf(me.getKey()), propertyType);
                break;
            }
            case VALUE: {
                try{
                    final JcrProperty property = getNode().getProperty(getPropertyName());
                    final int propertyType = property.getType();
                    String encodedValue;
                    if (property.isMultiple()) {
                        Object[] values = (Object[])value;
                        encodedValue = "";
                        for (int i = 0; i < values.length; i++) {
                            Object aValue = values[i];
                            String aValueAsString = PropertyTypeSupport.encodeValueAsString(aValue, propertyType);
                            if (i==0) {
                                encodedValue = aValueAsString;
                            } else {
                                encodedValue = encodedValue+","+aValueAsString;
                            }
                        }
                        encodedValue = "["+encodedValue+"]";
                    } else {
                        encodedValue = PropertyTypeSupport.encodeValueAsString(value, propertyType);
                    }
                    if (propertyType!=PropertyType.STRING && propertyType!=PropertyType.NAME) {
                        encodedValue = "{"+PropertyType.nameFromValue(propertyType)+"}"+encodedValue;
                    }
                    jcrNode.setPropertyValue(me.getKey(), encodedValue);
                } catch(Exception e) {
                    // emergency fallback
                    jcrNode.setPropertyValue(me.getKey(), String.valueOf(value));
                }
                break;
            }
            case MULTIPLE: {
                if (!(value instanceof Integer)) {
                    // value must be an integer
                    return;
                }
                final Integer newIsMultipleValue = (Integer) value;
                final boolean newIsMultiple = newIsMultipleValue==1;
                final JcrProperty property = getNode().getProperty(getPropertyName());
                final boolean oldIsMultiple = property.isMultiple();
                if (newIsMultiple==oldIsMultiple) {
                    // then nothing is to be done
                    return;
                }
                final String oldPropertyValue = getNode().getProperties().getValue(getPropertyName());
                // split {type} prefix from value
                int cPos = oldPropertyValue.indexOf("}");
                final String prefix;
                final String rawValue;
                if (cPos==-1) {
                    prefix = "";
                    rawValue = oldPropertyValue;
                } else {
                    prefix = oldPropertyValue.substring(0, cPos+1);
                    rawValue = oldPropertyValue.substring(cPos+1);
                }
                String newValue;
                if (newIsMultiple) {
                    newValue = prefix + "[" + rawValue + "]";
                } else {
                    newValue = rawValue.substring(1, rawValue.length()-1);
                    int commaPos = newValue.indexOf(",");
                    if (commaPos!=-1) {
                        newValue = newValue.substring(0, commaPos);
                    }
                    newValue = prefix + newValue;
                }
                jcrNode.setPropertyValue(getPropertyName(), newValue);
                break;
            }
            }

            view.refreshContent();
        }

        public int getPropertyType() {
            IPropertyDescriptor pd = (IPropertyDescriptor) element;
            Map.Entry me = (Entry) pd.getId();
            String value = String.valueOf(me.getValue());
            return PropertyTypeSupport.propertyTypeOfString(value);
        }

        public String getNewPropertyName() {
            JcrTextPropertyDescriptor pd = (JcrTextPropertyDescriptor) element;
            if (pd.getNewPropertyName()!=null) {
                return pd.getNewPropertyName();
            } else {
                return getPropertyName();
            }
        }
    }
    
    private class NewRowField extends Field {

        private final NewRow newRow;

        NewRowField(NewRow newRow) {
            super(newRow);
            this.newRow = newRow;
        }
        
        @Override
        public boolean canEdit() {
            return true;
        }
        
        @Override
        public int getPropertyType() {
            return newRow.getType();
        }
        
        @Override
        public Object getValue() {
            if (columnId==ColumnId.NAME) {
                return newRow.getName();
            } else if (columnId==ColumnId.VALUE) {
                final int propertyType = newRow.getType();
                if (propertyType==PropertyType.BOOLEAN) {
                    try{
                        if (Boolean.parseBoolean(String.valueOf(newRow.getValue()))) {
                            return 1;
                        } else {
                            return 0;
                        }
                    } catch(Exception e) {
                        return 0;
                    }
                }
                return newRow.getValue();
            } else if (columnId==ColumnId.TYPE) {
                final int propertyType = newRow.getType();
                if (propertyType!=-1) {
                    return PropertyTypeSupport.indexOfPropertyType(propertyType);
                } else {
                    //TODO: otherwise hardcode to STRING
                    return PropertyTypeSupport.indexOfPropertyType(PropertyType.STRING);
                }
            } else if (columnId==ColumnId.MULTIPLE) {
                //TODO
                return 0;
            } else {
                return null;
            }
        }
        
        @Override
        public String getPropertyName() {
            return String.valueOf(newRow.getName());
        }
        
        @Override
        public String getNewPropertyName() {
            return getPropertyName();
        }
        
        @Override
        public void setValue(Object element, Object value) {
            if (getValue().equals(value)) {
                // then ignore this
                return;
            }
            if (columnId==ColumnId.NAME) {
                String newName = String.valueOf(value);
                ModifiableProperties props = getNode().getProperties();
                int cnt = 1;
                while(props.getValue(newName)!=null) {
                    newName = String.valueOf(value)+(cnt++);
                }
                newRow.setName(newName);
            } else if (columnId==ColumnId.VALUE) {
                newRow.setValue(PropertyTypeSupport.encodeValueAsString(value, getPropertyType()));
            } else if (columnId==ColumnId.TYPE) {
                int propertyType = PropertyTypeSupport.propertyTypeOfIndex((Integer)value);
                newRow.setType(propertyType);
            } else if (columnId==ColumnId.MULTIPLE) {
                // do nothing at the moment
                //TODO
            } else {
                // otherwise non-editable
                return;
            }
            handleNewRowUpdate(newRow);
        }
    }
    
    private class DecimalValidator implements ICellEditorValidator {

        private final CellEditor editor;

        DecimalValidator(CellEditor editor) {
            this.editor = editor;
        }
        
        @Override
        public String isValid(Object value) {
            Control cn = editor.getControl();
            TableViewer tw = tableViewer;
            Color red = new Color(Display.getCurrent(), new RGB(255, 100, 100));
            cn.setBackground(red);
            return null;
        }
        
    }

    public JcrEditingSupport(JcrPropertiesView view, TableViewer viewer, ColumnId columnType) {
        super(viewer);
        this.view = view;
        this.columnId = columnType;
        this.tableViewer = viewer;
    }

    @Override
    protected CellEditor getCellEditor(Object element) {
        try{
            final CellEditor result = doGetCellEditor(element);
            if (result!=null) {
                Field field = asField(element);
                view.setLastValueEdited(field.getPropertyName(), field.getNewPropertyName(), columnId);
            }
            return result;
        } catch(Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    protected CellEditor doGetCellEditor(Object element) {
        if (!canEdit(element)) {
            return null;
        }
        switch(columnId) {
        case NAME: {
            // no validator needed - any string is OK
            return new TextCellEditor(tableViewer.getTable());
        }
        case TYPE: {
            // using a dropdown editor
            final ComboBoxCellEditor editor = new ComboBoxCellEditor(tableViewer.getTable(), 
                    PropertyTypeSupport.PROPERTY_TYPES, SWT.NONE);
            editor.setActivationStyle(ComboBoxCellEditor.DROP_DOWN_ON_KEY_ACTIVATION | 
                    ComboBoxCellEditor.DROP_DOWN_ON_MOUSE_ACTIVATION |
                    ComboBoxCellEditor.DROP_DOWN_ON_TRAVERSE_ACTIVATION);
            return editor;
        }
        case VALUE: {
            final Field field = asField(element);
            if (getNode().getProperty(field.getPropertyName()).isMultiple()) {
                // then launch the MVPEditor instead of returning an editor here
                return new MVNCellEditor(tableViewer.getTable(), getNode(), field.getPropertyName());
            }
            if (field.getPropertyType()==PropertyType.DATE) {
                return new DateTimeCellEditor(tableViewer.getTable(), getNode(), field.getPropertyName());
            }
            if (field.getPropertyType()==PropertyType.BOOLEAN) {
                return new ComboBoxCellEditor(tableViewer.getTable(), new String[] {"false", "true"}, SWT.READ_ONLY);
            }
            CellEditor editor;
            if (field.getPropertyName().equals("jcr:primaryType")) {
                editor = new TextCellEditor(tableViewer.getTable()) {
                    @Override
                    protected Control createControl(Composite parent) {
                        Text text = (Text) super.createControl(parent);
                        Repository repository = ServerUtil.getDefaultRepository(getNode().getProject());
                        NodeTypeRegistry ntManager = (repository==null) ? null : repository.getNodeTypeRegistry();
                        if (ntManager == null) {
                            return text;
                        }
                        try {
                            Collection<String> types = ntManager.getAllowedPrimaryChildNodeTypes(getNode().getParent().getPrimaryType());
                            SimpleContentProposalProvider proposalProvider = new SimpleContentProposalProvider(types.toArray(new String[0]));
                            proposalProvider.setFiltering(true);
                            ContentProposalAdapter adapter = new ContentProposalAdapter(text, new TextContentAdapter(),
                                    proposalProvider, null, null);
                            adapter.setPropagateKeys(true);
                            adapter
                                    .setProposalAcceptanceStyle(ContentProposalAdapter.PROPOSAL_REPLACE);
                            return text;
                        } catch (RepositoryException e) {
                            return text;
                        }
                    }
                };
            } else {
                editor = new TextCellEditor(tableViewer.getTable());
            }
            // value might require a validator depending on the property type
            int propertyType = getNode().getPropertyType(field.getPropertyName());
            switch(propertyType) {
            case PropertyType.STRING:
            case PropertyType.NAME: {
                // no validator needed, any string is OK (for now)
                //TODO: check jcr rules for name
                break;
            }
            case PropertyType.DECIMAL: {
                editor.setValidator(new DecimalValidator(editor));
                break;
            }
            default: {
                // for the rest, no check implemented yet
                //TODO
                break;
            }
            }
            return editor;
        }
        case MULTIPLE: {
            if (element instanceof NewRow) {
                return null;
            }
            return new ComboBoxCellEditor(tableViewer.getTable(), new String[] {"false", "true"}, SWT.READ_ONLY);
        }
        default: {
            throw new IllegalStateException("Unknown columnId: "+columnId);
        }
        }
    }

    @Override
    protected boolean canEdit(Object element) {
        return asField(element).canEdit();
    }
    
    private Field asField(Object element) {
        if (element instanceof NewRow) {
            return new NewRowField((NewRow)element);
        } else {
            return new Field(element);
        }
    }

    @Override
    protected Object getValue(Object element) {
        return asField(element).getValue();
    }

    @Override
    protected void setValue(Object element, Object value) {
        Field field = asField(element);
        if (!field.canEdit()) {
            return;
        }
        String newPropertyName;
        if (columnId==ColumnId.NAME) {
            newPropertyName = String.valueOf(value);
        } else {
            newPropertyName = field.getPropertyName();
        }
        view.setLastValueEdited(field.getPropertyName(), newPropertyName, columnId);
        field.setValue(element, value);
    }

    void handleNewRowUpdate(NewRow newRow) {
        if (newRow.isComplete()) {
            tableViewer.remove(newRow);
            final JcrNode jcrNode = (JcrNode)tableViewer.getInput();
            final Integer type = newRow.getType();
            String encodeValueAsString = PropertyTypeSupport.encodeValueAsString(newRow.getValue(), type);
            if (type!=PropertyType.STRING && type!=PropertyType.NAME) {
                encodeValueAsString = "{"+PropertyType.nameFromValue(type)+"}"+encodeValueAsString;
            }
            final String propertyName = String.valueOf(newRow.getName());
            jcrNode.addProperty(propertyName, encodeValueAsString);
            view.refreshContent();
        } else {
            tableViewer.update(newRow, null);
        }
    }

    private JcrNode getNode() {
        return (JcrNode)tableViewer.getInput();
    }
    
}