Coverage Report - org.openpermis.editor.policy.presenter.ActionPresenter
 
Classes in this File Line Coverage Branch Coverage Complexity
ActionPresenter
0%
0/42
0%
0/6
1.308
ActionPresenter$1
0%
0/13
N/A
1.308
 
 1  
 /*
 2  
  * Copyright (c) 2009, Swiss Federal Department of Defence Civil Protection and Sport
 3  
  *                     (http://www.vbs.admin.ch)
 4  
  * Copyright (c) 2009, Ergon Informatik AG (http://www.ergon.ch)
 5  
  * All rights reserved.
 6  
  *
 7  
  * Licensed under the Open Permis License which accompanies this distribution,
 8  
  * and is available at http://www.openpermis.org/BSDlicenceKent.txt
 9  
  */
 10  
 package org.openpermis.editor.policy.presenter;
 11  
 
 12  
 import java.util.ArrayList;
 13  
 import java.util.List;
 14  
 
 15  
 import org.jdesktop.observablecollections.ObservableCollections;
 16  
 import org.jdesktop.observablecollections.ObservableList;
 17  
 import org.jdesktop.observablecollections.ObservableListListener;
 18  
 import org.slf4j.Logger;
 19  
 import org.slf4j.LoggerFactory;
 20  
 
 21  
 import org.openpermis.editor.policy.beans.PropertyChange;
 22  
 import org.openpermis.policy.ParameterList;
 23  
 import org.openpermis.policy.ParameterList.Parameter;
 24  
 import org.openpermis.policy.bean.ActionBean;
 25  
 
 26  
 /**
 27  
  * Presenter for a single {@link ActionBean}.
 28  
  * @since 0.1.0
 29  
  */
 30  0
 public class ActionPresenter extends PartPresenter<ActionBean> {
 31  
 
 32  
         //---- Static
 33  
 
 34  
         /**
 35  
          * The logger object of this class.
 36  
          * @since 0.1.0
 37  
          */
 38  0
         private static final Logger LOGGER =
 39  
                 LoggerFactory.getLogger(ActionPresenter.class);
 40  
 
 41  
         //---- State
 42  
 
 43  
         /**
 44  
          * @since 0.1.0
 45  
          */
 46  
         private String name;
 47  
 
 48  
         /**
 49  
          * @since 0.1.0
 50  
          */
 51  
         private final ObservableList<Parameter> presenterParameters;
 52  
 
 53  
         /**
 54  
          * Updater that keeps the model in sync with the observable parameters list.
 55  
          * @since 0.1.0
 56  
          */
 57  
         private final ObservableListListener parametersModelUpdater;
 58  
 
 59  
         //---- Constructors
 60  
 
 61  
         /**
 62  
          * Creates a new {@link ActionPresenter}.
 63  
          * @param model the action to work on.
 64  
          * @param context policy context that provides additional information.
 65  
          * @since 0.1.0
 66  
          */
 67  
         public ActionPresenter (ActionBean model, PolicyContext context)
 68  
         {
 69  0
                 super(model, context);
 70  
 
 71  0
                 LOGGER.debug("Presenter for [{}].", model);
 72  0
                 updateName();
 73  0
                 this.presenterParameters = createParameterList();
 74  
 
 75  0
                 this.parametersModelUpdater = new ObservableListListener() {
 76  
                         @SuppressWarnings("unchecked")
 77  
                         public void listElementPropertyChanged (ObservableList list, int index) {
 78  0
                                 LOGGER.debug("listElementPropertyChanged");
 79  0
                                 updateParametersAtModel();
 80  0
                         }
 81  
                         @SuppressWarnings("unchecked")
 82  
                         public void listElementReplaced (ObservableList list, int index, Object old) {
 83  0
                                 LOGGER.debug("listElementReplaced");
 84  0
                                 updateParametersAtModel();
 85  0
                         }
 86  
                         @SuppressWarnings("unchecked")
 87  
                         public void listElementsAdded (ObservableList list, int index, int length) {
 88  0
                                 LOGGER.debug("listElementsAdded");
 89  0
                                 updateParametersAtModel();
 90  0
                         }
 91  
                         @SuppressWarnings("unchecked")
 92  0
                         public void listElementsRemoved (ObservableList list, int index, List oldElements) {
 93  0
                                 LOGGER.debug("listElementsRemoved");
 94  0
                                 updateParametersAtModel();
 95  0
                         }
 96  
                 };
 97  
 
 98  0
                 this.presenterParameters.addObservableListListener(this.parametersModelUpdater);
 99  0
         }
 100  
 
 101  
         //---- Methods
 102  
 
 103  
         /**
 104  
          * Creates a new parameter list that contains all paramters bound at the model.
 105  
          * @return the list, never {@code null}.
 106  
          * @since 0.1.0
 107  
          */
 108  
         private ObservableList<Parameter> createParameterList () {
 109  0
                 ObservableList<Parameter> list =
 110  
                         ObservableCollections.observableList(new ArrayList<Parameter>());
 111  0
                 final ParameterList params = getModel().getParameters();
 112  0
                 for (int i = 0; i < params.getParameterCount(); i++) {
 113  0
                         list.add(new Parameter(params.getName(i), params.getType(i)));
 114  
                 }
 115  0
                 return list;
 116  
         }
 117  
 
 118  
         /**
 119  
          * Gets the {@link Parameter}s {@link ObservableList}.
 120  
          * @return the {@link Parameter}s {@link ObservableList}.
 121  
          * @since 0.1.0
 122  
          */
 123  
         public ObservableList<Parameter> getPresenterParameters () {
 124  0
                 return this.presenterParameters;
 125  
         }
 126  
 
 127  
         /**
 128  
          * Gets the name.
 129  
          * @return the name.
 130  
          * @since 0.1.0
 131  
          */
 132  
         public String getName () {
 133  0
                 return this.name;
 134  
         }
 135  
 
 136  
         /**
 137  
          * Sets the name of the model.
 138  
          * @param name the new name to set.
 139  
          * @since 0.1.0
 140  
          */
 141  
         public void setName (String name) {
 142  
                 try {
 143  
                         // update presenter
 144  0
                         this.name = name;
 145  
 
 146  
                         // trigger model
 147  0
                         change("name", this.name);
 148  0
                 } catch (final Exception e) {
 149  0
                         LOGGER.warn("Cannot set action name [" + name + "].", e);
 150  0
                 }
 151  0
         }
 152  
 
 153  
         /**
 154  
          * Writes the parameters in the model according to the presenter.
 155  
          * @since 0.1.0
 156  
          */
 157  
         private void updateParametersAtModel () {
 158  0
                 LOGGER.debug("updateParametersAtModel");
 159  0
                 ParameterList newModelParameterList = new ParameterList();
 160  0
                 for (Parameter parameter : this.presenterParameters) {
 161  0
                         newModelParameterList.add(parameter.getName(), parameter.getType());
 162  
                 }
 163  0
                 change("parameters", newModelParameterList);
 164  0
         }
 165  
 
 166  
         /**
 167  
          * Writes the parameters in the presenter according to the model.
 168  
          * @since 0.1.0
 169  
          */
 170  
         private void updateParametersAtPresenter () {
 171  0
                 LOGGER.debug("updateParametersAtPresenter");
 172  
 
 173  
                 // temporarily remove listener to avoid recursion
 174  0
                 this.presenterParameters.removeObservableListListener(this.parametersModelUpdater);
 175  
 
 176  
                 // update presenter: use *same* list to preserve *any* listener of editor or presenter
 177  0
                 this.presenterParameters.clear();
 178  0
                 this.presenterParameters.addAll(createParameterList());
 179  
 
 180  
                 // re-add listener to avoid recursion
 181  0
                 this.presenterParameters.addObservableListListener(this.parametersModelUpdater);
 182  0
         }
 183  
 
 184  
         //---- PropertyChange
 185  
 
 186  
         /**
 187  
          * Handles property changes of name.
 188  
          * @since 0.1.0
 189  
          */
 190  
         @PropertyChange(bean = ActionBean.class, property = "name")
 191  
         public void updateName () {
 192  0
                 final String oldName = this.name;
 193  0
                 this.name = getModel().getName();
 194  0
                 firePropertyChange("name", oldName, this.name);
 195  0
                 setTitleParameters(this.name == null ? "" : this.name.toString());
 196  0
         }
 197  
 
 198  
         /**
 199  
          * Handles property changes of parameters.
 200  
          * @since 0.1.0
 201  
          */
 202  
         @PropertyChange(bean = ActionBean.class, property = "parameters")
 203  
         public void updateParameters () {
 204  0
                 LOGGER.debug("updateParameters");
 205  0
                 updateParametersAtPresenter();
 206  0
         }
 207  
 
 208  
 }