code stringlengths 3 1.18M | language stringclasses 1 value |
|---|---|
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.ResourceAnnotations;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.EditField;
import org.rapla.gui.internal.edit.fields.BooleanField;
import org.rapla.gui.internal.edit.fields.ClassificationField;
import org.rapla.gui.internal.edit.fields.PermissionListField;
/****************************************************************
* This is the controller-class for the Resource-Edit-Panel *
****************************************************************/
class AllocatableEditUI extends AbstractEditUI<Allocatable> {
ClassificationField<Allocatable> classificationField;
PermissionListField permissionField;
BooleanField holdBackConflictsField;
boolean internal =false;
public AllocatableEditUI(RaplaContext contest, boolean internal) throws RaplaException {
super(contest);
this.internal = internal;
ArrayList<EditField> fields = new ArrayList<EditField>();
classificationField = new ClassificationField<Allocatable>(contest);
fields.add(classificationField );
permissionField = new PermissionListField(contest,getString("permissions"));
fields.add( permissionField );
if ( !internal)
{
holdBackConflictsField = new BooleanField(contest,getString("holdbackconflicts"));
fields.add(holdBackConflictsField );
}
setFields(fields);
}
public void mapToObjects() throws RaplaException {
classificationField.mapTo( objectList);
permissionField.mapTo( objectList);
if ( getName(objectList).length() == 0)
throw new RaplaException(getString("error.no_name"));
if ( !internal)
{
Boolean value = holdBackConflictsField.getValue();
if ( value != null)
{
for ( Allocatable alloc:objectList)
{
alloc.setAnnotation(ResourceAnnotations.KEY_CONFLICT_CREATION, value ? ResourceAnnotations.VALUE_CONFLICT_CREATION_IGNORE : null);
}
}
}
}
protected void mapFromObjects() throws RaplaException {
classificationField.mapFrom( objectList);
permissionField.mapFrom( objectList);
Set<Boolean> values = new HashSet<Boolean>();
for ( Allocatable alloc:objectList)
{
String annotation = alloc.getAnnotation( ResourceAnnotations.KEY_CONFLICT_CREATION);
boolean holdBackConflicts = annotation != null && annotation.equals( ResourceAnnotations.VALUE_CONFLICT_CREATION_IGNORE);
values.add(holdBackConflicts);
}
if ( !internal)
{
if ( values.size() == 1)
{
Boolean singleValue = values.iterator().next();
holdBackConflictsField.setValue( singleValue);
}
if ( values.size() > 1)
{
holdBackConflictsField.setFieldForMultipleValues();
}
}
classificationField.setTypeChooserVisible( !internal);
}
}
| Java |
package org.rapla.gui.internal.edit.fields;
public interface EditFieldWithLayout {
EditFieldLayout getLayout();
}
| Java |
package org.rapla.gui.internal.edit.fields;
import java.util.Collection;
public interface SetGetCollectionField<T> {
void setValues(Collection<T> values);
Collection<T> getValues();
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
public class AllocatableSelectField extends AbstractSelectField<Allocatable>
{
DynamicType dynamicTypeConstraint;
public AllocatableSelectField(RaplaContext context, DynamicType dynamicTypeConstraint){
super( context);
this.dynamicTypeConstraint = dynamicTypeConstraint;
}
@Override
protected Allocatable getValue(Object valueObject) {
if ( valueObject instanceof Allocatable)
{
return (Allocatable) valueObject;
}
else
{
return null;
}
}
@Override
protected String getNodeName(Allocatable selectedAllocatable)
{
return selectedAllocatable.getName(getI18n().getLocale());
}
@Override
public TreeModel createModel() throws RaplaException {
Allocatable[] allocatables;
if (dynamicTypeConstraint !=null)
{
ClassificationFilter filter = dynamicTypeConstraint.newClassificationFilter();
ClassificationFilter[] filters = new ClassificationFilter[] {filter};
allocatables = getQuery().getAllocatables(filters);
}
else
{
allocatables = getQuery().getAllocatables();
}
TreeModel treeModel = getTreeFactory().createClassifiableModel(allocatables);
if (dynamicTypeConstraint !=null)
{
TreeNode child = ((TreeNode)treeModel.getRoot()).getChildAt(0);
treeModel = new DefaultTreeModel( child );
}
return treeModel;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.text.JTextComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.toolkit.AWTColorUtil;
public class TextField extends AbstractEditField implements ActionListener,FocusListener,KeyListener, MultiEditField, SetGetField<String> {
JTextComponent field;
JComponent colorPanel;
JScrollPane scrollPane;
JButton colorChooserBtn ;
JPanel color;
Object oldValue;
Color currentColor;
boolean multipleValues = false; // indicator, shows if multiple different
// values are shown in this field
public final static int DEFAULT_LENGTH = 30;
public TextField(RaplaContext context)
{
this( context,"", 1, TextField.DEFAULT_LENGTH);
}
public TextField(RaplaContext context,String fieldName)
{
this( context,fieldName, 1, TextField.DEFAULT_LENGTH);
}
public TextField(RaplaContext sm,String fieldName, int rows, int columns)
{
super( sm);
setFieldName( fieldName );
if ( rows > 1 ) {
JTextArea area = new JTextArea();
field = area;
scrollPane = new JScrollPane( field, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
area.setColumns( columns);
area.setRows( rows );
area.setLineWrap( true);
} else {
field = new JTextField( columns);
}
addCopyPaste( field);
field.addFocusListener(this);
field.addKeyListener(this);
if (fieldName.equals("color"))
{
colorPanel = new JPanel();
color = new JPanel();
color.setPreferredSize(new Dimension(20,20));
color.setBorder( BorderFactory.createEtchedBorder());
colorPanel.setLayout(new BorderLayout());
colorPanel.add( field, BorderLayout.CENTER);
colorPanel.add( color, BorderLayout.WEST);
colorChooserBtn = new JButton();
if ( field instanceof JTextField)
{
((JTextField) field).setColumns( 7);
}
else
{
((JTextArea) field).setColumns( 7);
}
colorPanel.add( colorChooserBtn, BorderLayout.EAST);
colorChooserBtn.setText( getString("change") );
colorChooserBtn.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
currentColor = JColorChooser.showDialog(
colorPanel,
"Choose Background Color",
currentColor);
color.setBackground( currentColor );
if ( currentColor != null) {
field.setText( AWTColorUtil.getHexForColor( currentColor ));
}
fireContentChanged();
}
});
}
setValue("");
}
public String getValue() {
return field.getText().trim();
}
public void setValue(String string) {
if (string == null)
string = "";
field.setText(string);
oldValue = string;
if ( colorPanel != null) {
try
{
currentColor = AWTColorUtil.getColorForHex( string);
}
catch (NumberFormatException ex)
{
currentColor = null;
}
color.setBackground( currentColor );
}
}
public JComponent getComponent() {
if ( colorPanel!= null)
{
return colorPanel;
}
if ( scrollPane != null ) {
return scrollPane;
} else {
return field;
}
}
public void selectAll()
{
field.selectAll();
}
public void actionPerformed(ActionEvent evt) {
if (field.getText().equals(oldValue))
return;
oldValue = field.getText();
fireContentChanged();
}
public void focusLost(FocusEvent evt) {
if (field.getText().equals(oldValue))
return;
// checks if entry was executed
if (field.getText().equals("") && multipleValues)
// no set place holder for multiple values
setFieldForMultipleValues();
else
// yes: reset flag, because there is just one common entry
multipleValues = false;
oldValue = field.getText();
fireContentChanged();
}
public void focusGained(FocusEvent evt) {
Component focusedComponent = evt.getComponent();
Component parent = focusedComponent.getParent();
if(parent instanceof JPanel) {
((JPanel)parent).scrollRectToVisible(focusedComponent.getBounds(null));
}
// if the place holder shown for different values, the place holder
// should be deleted
if (multipleValues) {
setValue("");
// set font PLAIN (place holder is shown italic)
field.setFont(field.getFont().deriveFont(Font.PLAIN));
}
}
public void keyPressed(KeyEvent evt) {}
public void keyTyped(KeyEvent evt) {}
public void keyReleased(KeyEvent evt) {
if (field.getText().equals(oldValue))
return;
// reset flag, because there is just one common entry
if (multipleValues) {
multipleValues = false;
}
oldValue = field.getText();
fireContentChanged();
}
public void setFieldForMultipleValues() {
// set a place holder for multiple different values (italic)
field.setFont(field.getFont().deriveFont(Font.ITALIC));
field.setText(TextField.getOutputForMultipleValues());
multipleValues = true;
}
public boolean hasMultipleValues() {
return multipleValues;
}
static public String getOutputForMultipleValues() {
// place holder for mulitple different values
return "<multiple Values>";
}
}
| Java |
package org.rapla.gui.internal.edit.fields;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import javax.swing.DefaultListCellRenderer;
import javax.swing.DefaultListModel;
import javax.swing.JComponent;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JToolBar;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.rapla.entities.Category;
import org.rapla.entities.User;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.toolkit.RaplaButton;
public class GroupListField extends AbstractEditField implements ChangeListener, ActionListener, EditFieldWithLayout {
DefaultListModel model = new DefaultListModel();
JPanel panel = new JPanel();
JToolBar toolbar = new JToolBar();
CategorySelectField newCategory;
RaplaButton removeButton = new RaplaButton(RaplaButton.SMALL);
RaplaButton newButton = new RaplaButton(RaplaButton.SMALL);
JList list = new JList();
Set<Category> notAllList = new HashSet<Category>();
/**
* @param context
* @throws RaplaException
*/
public GroupListField(RaplaContext context) throws RaplaException {
super(context);
final Category rootCategory = getQuery().getUserGroupsCategory();
if ( rootCategory == null )
return;
newCategory = new CategorySelectField(context, rootCategory );
newCategory.setUseNull( false);
toolbar.add( newButton );
toolbar.add( removeButton );
toolbar.setFloatable( false );
panel.setLayout( new BorderLayout() );
panel.add( toolbar, BorderLayout.NORTH );
final JScrollPane jScrollPane = new JScrollPane(list, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
jScrollPane.setPreferredSize( new Dimension( 300, 150 ) );
panel.add( jScrollPane, BorderLayout.CENTER );
newButton.setText( getString( "group" ) + " " + getString( "add" ) );
removeButton.setText( getString( "group" ) + " " + getString( "remove" ) );
newButton.setIcon( getIcon( "icon.new" ) );
removeButton.setIcon( getIcon( "icon.remove" ) );
newCategory.addChangeListener( this );
newButton.addActionListener( this );
removeButton.addActionListener( this );
DefaultListCellRenderer cellRenderer = new DefaultListCellRenderer() {
private static final long serialVersionUID = 1L;
public Component getListCellRendererComponent(JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus)
{
Category category = (Category) value;
if ( value != null ) {
value = category.getPath( rootCategory
, getI18n().getLocale());
}
Component component = super.getListCellRendererComponent(list,value,index,isSelected,cellHasFocus);
if (notAllList.contains( category))
{
Font f =component.getFont().deriveFont(Font.ITALIC);
component.setFont(f);
}
return component;
}
};
setRenderer(cellRenderer);
}
@SuppressWarnings("unchecked")
private void setRenderer(DefaultListCellRenderer cellRenderer) {
list.setCellRenderer(cellRenderer );
}
public JComponent getComponent() {
return panel;
}
@Override
public EditFieldLayout getLayout() {
EditFieldLayout layout = new EditFieldLayout();
layout.setBlock( true);
layout.setVariableSized( false);
return layout;
}
public void mapFrom(List<User> users) {
Set<Category> categories = new LinkedHashSet<Category>();
// determination of the common categories/user groups
for (User user:users) {
categories.addAll(Arrays.asList(user.getGroups()));
}
Set<Category> notAll = new LinkedHashSet<Category>();
for ( Category group: categories)
{
for (User user:users)
{
if (!user.belongsTo( group))
{
notAll.add(group);
}
}
}
mapFromList(categories,notAll);
}
public void mapToList(Collection<Category> groups) {
groups.clear();
@SuppressWarnings({ "unchecked", "cast" })
Enumeration<Category> it = (Enumeration<Category>) model.elements();
while (it.hasMoreElements())
{
Category cat= it.nextElement();
groups.add( cat);
}
}
public void mapFromList(Collection<Category> groups) {
mapFromList(groups, new HashSet<Category>());
}
@SuppressWarnings("unchecked")
private void mapFromList(Collection<Category> groups,Set<Category> notToAll) {
model.clear();
this.notAllList = notToAll;
for ( Category cat:groups) {
model.addElement( cat );
}
list.setModel(model);
}
public void mapTo(List<User> users) {
for (User user:users)
{
for (Category cat : user.getGroups())
{
if (!model.contains( cat) && !notAllList.contains( cat))
{
user.removeGroup( cat);
}
}
@SuppressWarnings({ "unchecked", "cast" })
Enumeration<Category> it = (Enumeration<Category>) model.elements();
while (it.hasMoreElements())
{
Category cat= it.nextElement();
if ( !user.belongsTo( cat) && !notAllList.contains( cat))
{
user.addGroup( cat);
}
}
}
}
public void actionPerformed(ActionEvent evt) {
if ( evt.getSource() == newButton)
{
try {
newCategory.setValue( null );
newCategory.showDialog(newButton);
} catch (RaplaException ex) {
showException(ex,newButton);
}
}
if ( evt.getSource() == removeButton)
{
@SuppressWarnings("deprecation")
Object[] selectedValues = list.getSelectedValues();
for ( Object value: selectedValues)
{
Category group = (Category) value;
if (group != null) {
model.removeElement( group );
notAllList.remove( group);
fireContentChanged();
}
}
}
}
@SuppressWarnings("unchecked")
public void stateChanged(ChangeEvent evt) {
Collection<Category> newGroup = newCategory.getValues();
for ( Category group:newGroup)
{
notAllList.remove( group);
if ( ! model.contains( group ) ) {
model.addElement( group );
}
}
fireContentChanged();
list.repaint();
}
} | Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import javax.swing.BorderFactory;
import javax.swing.DefaultComboBoxModel;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.rapla.components.layout.TableLayout;
import org.rapla.entities.Category;
import org.rapla.entities.User;
import org.rapla.entities.domain.Permission;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
public class PermissionField extends AbstractEditField implements ChangeListener, ActionListener {
SetGetField<Category> groupSelect;
ListField<User> userSelect;
JPanel panel = new JPanel();
JPanel reservationPanel;
Permission permission;
JComboBox startSelection = new JComboBox();
JComboBox endSelection = new JComboBox();
DateField startDate;
DateField endDate;
LongField minAdvance;
LongField maxAdvance;
ListField<Integer> accessField;
@SuppressWarnings("unchecked")
public PermissionField(RaplaContext context) throws RaplaException {
super( context);
panel.setBorder(BorderFactory.createEmptyBorder(5,8,5,8));
double pre =TableLayout.PREFERRED;
double fill =TableLayout.FILL;
panel.setLayout( new TableLayout( new double[][]
{{fill, 5}, // Columns
{pre,5,pre,5,pre}} // Rows
));
JPanel userPanel = new JPanel();
panel.add( userPanel , "0,0,f,f" );
userPanel.setLayout( new TableLayout( new double[][]
{{pre, 10, fill, 5}, // Columns
{pre,5,pre,5,pre}} // Rows
));
userSelect = new UserListField( context );
userPanel.add( new JLabel(getString("user") + ":"), "0,0,l,f" );
userPanel.add( userSelect.getComponent(),"2,0,l,f" );
Category rootCategory = getQuery().getUserGroupsCategory();
if ( rootCategory != null) {
AbstractEditField groupSelect;
if (rootCategory.getDepth() > 2) {
CategorySelectField field= new CategorySelectField(getContext(), rootCategory);
this.groupSelect = field;
groupSelect = field;
} else {
CategoryListField field = new CategoryListField(getContext(), rootCategory);
this.groupSelect = field;
groupSelect = field;
}
userPanel.add( new JLabel(getString("group") + ":"), "0,2,l,f" );
userPanel.add( groupSelect.getComponent(),"2,2,l,f" );
groupSelect.addChangeListener( this );
}
reservationPanel = new JPanel();
panel.add( reservationPanel , "0,2,f,f" );
reservationPanel.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEmptyBorder(), getString("allocatable_in_timeframe") + ":" ));
reservationPanel.setLayout( new TableLayout( new double[][]
{{pre,3, pre, 5, pre, 5}, // Columns
{pre, 5, pre}} // Rows
));
reservationPanel.add( new JLabel( getString("start_date") + ":" ) , "0,0,l,f" );
reservationPanel.add( startSelection , "2,0,l,f" );
startSelection.setModel( createSelectionModel() );
startSelection.setSelectedIndex( 0 );
startDate = new DateField(context);
reservationPanel.add( startDate.getComponent() , "4,0,l,f" );
minAdvance = new LongField(context,new Long(0) );
reservationPanel.add( minAdvance.getComponent() , "4,0,l,f" );
reservationPanel.add( new JLabel( getString("end_date") + ":" ), "0,2,l,f" );
reservationPanel.add( endSelection , "2,2,l,f" );
endSelection.setModel( createSelectionModel() );
endSelection.setSelectedIndex( 0 );
endDate = new DateField(context);
reservationPanel.add( endDate.getComponent() , "4,2,l,f" );
maxAdvance = new LongField(context, new Long(1) );
reservationPanel.add( maxAdvance.getComponent() , "4,2,l,f" );
userPanel.add( new JLabel(getString("permission.access") + ":"), "0,4,f,f" );
Collection<Integer> vector = new ArrayList<Integer>();
for (Integer accessLevel:Permission.ACCESS_LEVEL_NAMEMAP.keySet())
{
vector.add( accessLevel ) ;
}
accessField = new ListField<Integer>(context, vector );
accessField.setRenderer( new DefaultListCellRenderer() {
private static final long serialVersionUID = 1L;
public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
if (value != null) {
String key = Permission.ACCESS_LEVEL_NAMEMAP.get( ((Integer) value).intValue() );
value = getI18n().getString("permission." + key );
}
return super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus );
}}
);
userPanel.add( accessField.getComponent(), "2,4,f,f" );
toggleVisibility();
userSelect.addChangeListener( this );
startSelection.addActionListener(this);
minAdvance.addChangeListener(this);
startDate.addChangeListener(this);
endSelection.addActionListener(this);
maxAdvance.addChangeListener(this);
endDate.addChangeListener(this);
accessField.addChangeListener(this);
panel.revalidate();
}
public JComponent getComponent() {
return panel;
}
@SuppressWarnings("unchecked")
private DefaultComboBoxModel createSelectionModel() {
DefaultComboBoxModel model = new DefaultComboBoxModel();
model.addElement(getString( "open" ) );
model.addElement(getString( "fixed_date") );
model.addElement(getString( "x_days_advance") );
return model;
}
private void toggleVisibility() {
int level = accessField.getValue().intValue();
reservationPanel.setVisible( level >= Permission.ALLOCATE && level < Permission.ADMIN);
int i = startSelection.getSelectedIndex();
startDate.getComponent().setVisible( i == 1 );
minAdvance.getComponent().setVisible( i == 2 );
int j = endSelection.getSelectedIndex();
endDate.getComponent().setVisible( j == 1 );
maxAdvance.getComponent().setVisible( j == 2 );
}
boolean listenersDisabled = false;
public void setValue(Permission value) {
try {
listenersDisabled = true;
permission = value;
int startIndex = 0;
if ( permission.getStart() != null )
startIndex = 1;
if ( permission.getMinAdvance() != null )
startIndex = 2;
startSelection.setSelectedIndex( startIndex );
int endIndex = 0;
if ( permission.getEnd() != null )
endIndex = 1;
if ( permission.getMaxAdvance() != null )
endIndex = 2;
endSelection.setSelectedIndex( endIndex );
startDate.setValue( permission.getStart());
minAdvance.setValue( permission.getMinAdvance());
endDate.setValue(permission.getEnd() );
maxAdvance.setValue(permission.getMaxAdvance());
if ( groupSelect != null )
{
groupSelect.setValue( permission.getGroup());
}
userSelect.setValue(permission.getUser() );
accessField.setValue( permission.getAccessLevel() );
toggleVisibility();
} finally {
listenersDisabled = false;
}
}
public void actionPerformed(ActionEvent evt) {
if ( listenersDisabled )
return;
if (evt.getSource() == startSelection) {
int i = startSelection.getSelectedIndex();
if ( i == 0 ) {
permission.setStart( null );
permission.setMinAdvance( null );
}
if ( i == 1 ) {
Date today = getQuery().today();
permission.setStart( today );
startDate.setValue( today);
} if ( i == 2 ) {
permission.setMinAdvance( new Integer(0) );
minAdvance.setValue( new Integer(0 ));
}
}
if (evt.getSource() == endSelection) {
int i = endSelection.getSelectedIndex();
if ( i == 0 ) {
permission.setEnd( null );
permission.setMaxAdvance( null );
}
if ( i == 1 ) {
Date today = getQuery().today();
permission.setEnd( today );
endDate.setValue( today);
} if ( i == 2 ) {
permission.setMaxAdvance( new Integer( 30 ) );
maxAdvance.setValue( new Integer(30));
}
}
toggleVisibility();
fireContentChanged();
}
public Permission getValue() {
return permission;
}
public void stateChanged(ChangeEvent evt) {
if ( listenersDisabled )
return;
Permission perm = permission;
if (evt.getSource() == groupSelect) {
perm.setGroup(groupSelect.getValue() );
userSelect.setValue(perm.getUser()) ;
} else if (evt.getSource() == userSelect) {
perm.setUser( userSelect.getValue());
if ( groupSelect != null )
groupSelect.setValue(perm.getGroup());
} else if (evt.getSource() == startDate) {
perm.setStart(startDate.getValue() );
} else if (evt.getSource() == minAdvance) {
perm.setMinAdvance( minAdvance.getIntValue());
} else if (evt.getSource() == endDate) {
perm.setEnd(endDate.getValue());
} else if (evt.getSource() == maxAdvance) {
perm.setMaxAdvance(maxAdvance.getIntValue() );
} else if (evt.getSource() == accessField ) {
perm.setAccessLevel( accessField.getValue() );
toggleVisibility();
}
fireContentChanged();
}
class UserListField extends ListField<User> {
public UserListField(RaplaContext sm) throws RaplaException{
super(sm,true);
setVector(Arrays.asList(getQuery().getUsers() ));
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import org.rapla.entities.RaplaObject;
import org.rapla.entities.RaplaType;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Reservation;
import org.rapla.entities.dynamictype.Classifiable;
import org.rapla.entities.dynamictype.Classification;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.entities.dynamictype.DynamicTypeAnnotations;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.internal.common.NamedListCellRenderer;
import org.rapla.gui.internal.edit.ClassificationEditUI;
import org.rapla.gui.toolkit.RaplaListComboBox;
/****************************************************************
* This is the base-class for all Classification-Panels *
****************************************************************/
public class ClassificationField<T extends Classifiable> extends AbstractEditField
implements EditFieldWithLayout,
ActionListener
{
JPanel content = new JPanel();
RaplaListComboBox typeSelector;
ClassificationEditUI editUI;
DynamicType oldDynamicType;
List<Classification> oldClassifications; // enhancement to array
final String multipleValues = TextField.getOutputForMultipleValues();
public ClassificationField(RaplaContext context) {
super(context);
editUI = new ClassificationEditUI(context);
setFieldName("type");
content.setBorder(BorderFactory.createEmptyBorder(3, 2, 3, 2));
}
@Override
public EditFieldLayout getLayout() {
EditFieldLayout layout = new EditFieldLayout();
layout.setBlock( true);
layout.setVariableSized( true);
return layout;
}
public void mapTo(List<T> list) throws RaplaException {
List<Classification> classifications = editUI.getObjects();
for (int i = 0; i < list.size(); i++)
{
Classification classification = classifications.get( i );
Classifiable x = list.get(i);
x.setClassification(classification);
}
editUI.mapToObjects();
}
public void setTypeChooserVisible( boolean visible)
{
if ( typeSelector != null)
{
typeSelector.setVisible( visible);
}
}
@SuppressWarnings("unchecked")
public void mapFrom(List<T> list) throws RaplaException {
content.removeAll();
List<Classifiable> classifiables = new ArrayList<Classifiable>();
// read out Classifications from Classifiable
List<Classification> classifications = new ArrayList<Classification>();
for (Classifiable classifiable:list)
{
classifiables.add( classifiable);
Classification classification = classifiable.getClassification();
classifications.add(classification);
}
// commit Classifications to ClassificationEditUI
editUI.setObjects(classifications);
oldClassifications = classifications;
// checks unity from RaplaTypes of all Classifiables
Set<RaplaType> raplaTypes = new HashSet<RaplaType>();
for (Classifiable c : classifiables) {
raplaTypes.add(((RaplaObject) c).getRaplaType());
}
RaplaType raplaType;
// if there is an unitary type then set typ
if (raplaTypes.size() == 1) {
raplaType = raplaTypes.iterator().next();
} else {
return;
}
String classificationType = null;
if (Reservation.TYPE.equals(raplaType)) {
classificationType = DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESERVATION;
} else if (Allocatable.TYPE.equals(raplaType)) {
boolean arePersons = true;
// checks if Classifiables are person
for (Classifiable c : classifiables) {
if (!((Allocatable) c).isPerson()) {
arePersons = false;
}
}
if (arePersons) {
classificationType = DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON;
} else {
classificationType = DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESOURCE;
}
}
DynamicType[] types = getQuery().getDynamicTypes(classificationType);
// determine DynamicTypes of Classifications
Set<DynamicType> dynamicTypes = new HashSet<DynamicType>();
for (Classification c : classifications) {
dynamicTypes.add(c.getType());
}
DynamicType dynamicType;
// checks if there is a common DynamicType?
if (dynamicTypes.size() == 1)
// set dynamicTyp
dynamicType = dynamicTypes.iterator().next();
else
dynamicType = null;
oldDynamicType = dynamicType;
RaplaListComboBox jComboBox = new RaplaListComboBox(getContext(),types);
typeSelector = jComboBox;
typeSelector.setEnabled( types.length > 1);
if (dynamicType != null)
// set common dynamicType of the Classifications in ComboBox
typeSelector.setSelectedItem(dynamicType);
else {
// ... otherwise set place holder for the several values
typeSelector.addItem(multipleValues);
typeSelector.setSelectedItem(multipleValues);
}
typeSelector.setRenderer(new NamedListCellRenderer(getI18n().getLocale()));
typeSelector.addActionListener(this);
content.setLayout(new BorderLayout());
JPanel container = new JPanel();
container.setLayout(new BorderLayout());
container.add(typeSelector, BorderLayout.WEST);
content.add(container, BorderLayout.NORTH);
JComponent editComponent = editUI.getComponent();
JScrollPane scrollPane = new JScrollPane(editComponent,JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
scrollPane.setViewportView(editComponent);
scrollPane.setBorder(BorderFactory.createEtchedBorder());
scrollPane.setMinimumSize(new Dimension(300, 100));
scrollPane.setPreferredSize(new Dimension(500, 340));
scrollPane.getVerticalScrollBar().setUnitIncrement( 10);
content.add(scrollPane, BorderLayout.CENTER);
}
// The DynamicType has changed
public void actionPerformed(ActionEvent event) {
try {
Object source = event.getSource();
if (source == typeSelector) {
// checks if a DynamicType has been selected in ComboBox
if (typeSelector.getSelectedItem() instanceof DynamicType) {
// delete place holder for the several values
typeSelector.removeItem(multipleValues);
DynamicType dynamicType = (DynamicType) typeSelector
.getSelectedItem();
// checks if no new DynmicType has been selected
if (dynamicType.equals(oldDynamicType))
// yes: set last Classifications again
editUI.setObjects(oldClassifications);
else {
// no: set new Classifications
List<Classification> newClassifications = new ArrayList<Classification>();
List<Classification> classifications = editUI.getObjects();
for (int i = 0; i < classifications.size(); i++) {
Classification classification = classifications.get(i);
// checks if Classification hast already the new
// selected DynamicType
if (dynamicType.equals(classification .getType())) {
// yes: adopt Classification
newClassifications.add( classification );
} else {
// no: create new Classification
newClassifications.add( dynamicType.newClassification(classification));
}
}
// set new Classifications in ClassificationEditUI
editUI.setObjects(newClassifications);
}
}
}
} catch (RaplaException ex) {
showException(ex, content);
}
}
public JComponent getComponent() {
return content;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.ListCellRenderer;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.toolkit.RaplaListComboBox;
public class ListField<T> extends AbstractEditField implements ActionListener,FocusListener, MultiEditField, SetGetField<T>, SetGetCollectionField<T> {
JPanel panel;
JComboBox field;
protected String nothingSelected;
Vector<Object> list;
boolean multipleValues = false; // indicator, shows if multiple different
// values are shown in this field
final String multipleValuesOutput = TextField.getOutputForMultipleValues();
boolean includeNothingSelected;
public ListField(RaplaContext context, Collection<T> v)
{
this(context, false);
setVector(v);
}
public ListField(RaplaContext sm, boolean includeNothingSelected)
{
super(sm);
this.includeNothingSelected = includeNothingSelected;
setFieldName(fieldName);
panel = new JPanel();
panel.setOpaque(false);
field = new RaplaListComboBox(sm);
field.addActionListener(this);
panel.setLayout(new BorderLayout());
panel.add(field, BorderLayout.WEST);
nothingSelected = getString("nothing_selected");
field.addFocusListener(this);
}
@SuppressWarnings("unchecked")
public void setVector(Collection<T> v) {
this.list = new Vector<Object>(v);
if ( includeNothingSelected)
{
list.insertElementAt(nothingSelected, 0);
}
DefaultComboBoxModel aModel = new DefaultComboBoxModel(list);
field.setModel(aModel);
}
@SuppressWarnings("unchecked")
public void setRenderer(ListCellRenderer renderer) {
field.setRenderer(renderer);
}
public Collection<T> getValues() {
Object value = field.getSelectedItem();
if (list.contains(nothingSelected) && nothingSelected.equals(value)) {
return Collections.emptyList();
} else {
@SuppressWarnings("unchecked")
T casted = (T) value;
return Collections.singletonList( casted);
}
}
public T getValue()
{
Collection<T> values = getValues();
if ( values.size() == 0)
{
return null;
}
else
{
T first = values.iterator().next();
return first;
}
}
public void setValue(T object)
{
List<T> list;
if ( object == null)
{
list = Collections.emptyList();
}
else
{
list = Collections.singletonList(object);
}
setValues(list);
}
public void setValues(Collection<T> value) {
if (list.contains(nothingSelected) && (value == null || value.size() == 0) ) {
field.setSelectedItem(nothingSelected);
} else {
if ( value != null && value.size() > 0)
{
T first = value.iterator().next();
field.setSelectedItem(first);
}
else
{
field.setSelectedItem(null);
}
}
}
public JComponent getComponent() {
return panel;
}
public void actionPerformed(ActionEvent evt) {
// checks if a new common value has been set
if (multipleValues && field.getSelectedItem() != multipleValuesOutput) {
// delete place holder for multiple different values
multipleValues = false;
field.removeItem(multipleValuesOutput);
}
fireContentChanged();
}
public void focusGained(FocusEvent evt) {
Component focusedComponent = evt.getComponent();
Component parent = focusedComponent.getParent();
if (parent instanceof JPanel) {
((JPanel) parent).scrollRectToVisible(focusedComponent
.getBounds(null));
}
}
public void focusLost(FocusEvent evt) {
}
// implementation of interface MultiEditField
public boolean hasMultipleValues() {
return multipleValues;
}
// implementation of interface MultiEditField
@SuppressWarnings("unchecked")
public void setFieldForMultipleValues() {
multipleValues = true;
// place holder for multiple different values
field.addItem(multipleValuesOutput);
field.setSelectedItem(multipleValuesOutput);
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.util.Vector;
import org.rapla.entities.Category;
import org.rapla.framework.RaplaContext;
public class CategoryListField extends ListField<Category> {
Category rootCategory;
public CategoryListField(RaplaContext context,Category rootCategory) {
super(context, true);
this.rootCategory = rootCategory;
Category[] obj = rootCategory.getCategories();
Vector<Category> list = new Vector<Category>();
for (int i=0;i<obj.length;i++)
list.add(obj[i]);
setVector(list);
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.util.ArrayList;
import javax.swing.JComponent;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.EditField;
import org.rapla.gui.RaplaGUIComponent;
/** Base class for most rapla edit fields. Provides some mapping
functionality such as reflection invocation of getters/setters.
A fieldName "username" will result in a getUsername() and setUsername()
method.
*/
public abstract class AbstractEditField extends RaplaGUIComponent
implements EditField
{
String fieldName;
ArrayList<ChangeListener> listenerList = new ArrayList<ChangeListener>();
public AbstractEditField(RaplaContext context) {
super(context);
}
public void addChangeListener(ChangeListener listener) {
listenerList.add(listener);
}
public void removeChangeListener(ChangeListener listener) {
listenerList.remove(listener);
}
public ChangeListener[] getChangeListeners() {
return listenerList.toArray(new ChangeListener[]{});
}
protected void fireContentChanged() {
if (listenerList.size() == 0)
return;
ChangeEvent evt = new ChangeEvent(this);
ChangeListener[] listeners = getChangeListeners();
for (int i = 0;i<listeners.length; i++) {
listeners[i].stateChanged(evt);
}
}
abstract public JComponent getComponent();
public void setFieldName(String fieldName) {
this.fieldName = fieldName;
}
public String getFieldName() {
return this.fieldName;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.rapla.components.calendar.RaplaNumber;
import org.rapla.framework.RaplaContext;
public class LongField extends AbstractEditField implements ChangeListener, FocusListener, MultiEditField, SetGetField<Long>{
JPanel panel = new JPanel();
RaplaNumber field;
boolean multipleValues = false; // indicator, shows if multiple different
// values are shown in this field
JLabel multipleValuesLabel = new JLabel();
public LongField(RaplaContext context, String fieldName) {
this(context, (Long)null);
setFieldName(fieldName);
}
public LongField(RaplaContext context) {
this(context, (Long)null);
}
public LongField(RaplaContext context, Long minimum)
{
super(context);
panel.setLayout(new BorderLayout());
panel.setOpaque(false);
field = new RaplaNumber(minimum, minimum, null, minimum == null);
addCopyPaste(field.getNumberField());
field.setColumns(8);
field.addChangeListener(this);
panel.add(field, BorderLayout.WEST);
panel.add(multipleValuesLabel, BorderLayout.CENTER);
field.addFocusListener(this);
}
public Long getValue() {
if (field.getNumber() != null)
return new Long(field.getNumber().longValue());
else
return null;
}
public Integer getIntValue() {
if (field.getNumber() != null)
return new Integer(field.getNumber().intValue());
else
return null;
}
public void setValue(Long object) {
if (object != null) {
field.setNumber( object);
} else {
field.setNumber(null);
}
}
public void setValue(Integer object) {
if (object != null) {
field.setNumber( object);
} else {
field.setNumber(null);
}
}
public void stateChanged(ChangeEvent evt) {
// if entry was executed: a common value has been set -> change flag, no
// place holder has to be shown anymore
if (multipleValues) {
multipleValues = false;
multipleValuesLabel.setText("");
}
fireContentChanged();
}
public JComponent getComponent() {
return panel;
}
public void focusGained(FocusEvent evt) {
Component focusedComponent = evt.getComponent();
Component parent = focusedComponent.getParent();
if (parent instanceof JPanel) {
((JPanel) parent).scrollRectToVisible(focusedComponent
.getBounds(null));
}
}
public void focusLost(FocusEvent evt) {
}
// implementation for interface MultiEditField
public boolean hasMultipleValues() {
return multipleValues;
}
// implementation for interface MultiEditField
public void setFieldForMultipleValues() {
multipleValues = true;
// place holder for multiple different values:
multipleValuesLabel.setText(TextField.getOutputForMultipleValues());
multipleValuesLabel.setFont(multipleValuesLabel.getFont().deriveFont(Font.ITALIC));
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import javax.swing.tree.TreeModel;
import org.rapla.entities.Category;
import org.rapla.framework.RaplaContext;
public class CategorySelectField extends AbstractSelectField<Category>
{
Category rootCategory;
public CategorySelectField(RaplaContext context,Category rootCategory){
this( context, rootCategory, null);
}
public CategorySelectField(RaplaContext context,Category rootCategory, Category defaultCategory) {
super( context, defaultCategory);
this.rootCategory = rootCategory;
}
@Override
protected String getNodeName(Category selectedCategory)
{
return selectedCategory.getPath(rootCategory,getI18n().getLocale());
}
@Override
public TreeModel createModel() {
return getTreeFactory().createModel(rootCategory);
}
public Category getRootCategory()
{
return rootCategory;
}
public void setRootCategory(Category rootCategory)
{
this.rootCategory = rootCategory;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import javax.swing.BorderFactory;
import javax.swing.DefaultListCellRenderer;
import javax.swing.DefaultListModel;
import javax.swing.JComponent;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Permission;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.internal.edit.RaplaListEdit;
import org.rapla.gui.toolkit.EmptyLineBorder;
/**
* @author Christopher Kohlhaas
*/
public class PermissionListField extends AbstractEditField implements EditFieldWithLayout
{
JList permissionList = new JList();
JPanel jPanel = new JPanel();
PermissionField permissionField;
private RaplaListEdit<Permission> listEdit;
Listener listener = new Listener();
Allocatable firstAllocatable;
DefaultListModel model = new DefaultListModel();
Permission selectedPermission = null;
int selectedIndex = 0;
List<Permission> notAllList = new ArrayList<Permission>();
public PermissionListField(RaplaContext context, String fieldName) throws RaplaException {
super(context);
permissionField = new PermissionField(context);
super.setFieldName(fieldName);
jPanel.setLayout(new BorderLayout());
listEdit = new RaplaListEdit<Permission>(getI18n(), permissionField.getComponent(), listener);
jPanel.add(listEdit.getComponent(), BorderLayout.CENTER);
jPanel.setBorder(BorderFactory.createTitledBorder(new EmptyLineBorder(), getString("permissions")));
permissionField.addChangeListener(listener);
}
public JComponent getComponent() {
return jPanel;
}
public EditFieldLayout getLayout()
{
EditFieldLayout layout = new EditFieldLayout();
return layout;
}
public void mapTo(List<Allocatable> list) {
for (Allocatable allocatable :list)
{
for (Permission perm : allocatable.getPermissions())
{
if (!model.contains( perm) )
{
allocatable.removePermission(perm);
}
}
@SuppressWarnings({ "unchecked", "cast" })
Enumeration<Permission> it = (Enumeration<Permission>) model.elements();
while (it.hasMoreElements())
{
Permission perm= it.nextElement();
if ( !hasPermission(allocatable, perm) && !isNotForAll( perm))
{
allocatable.addPermission( perm);
}
}
}
}
private boolean hasPermission(Allocatable allocatable, Permission permission) {
for (Permission perm: allocatable.getPermissions())
{
if (perm.equals( permission))
{
return true;
}
}
return false;
}
@SuppressWarnings("unchecked")
public void mapFrom(List<Allocatable> list) {
model.clear();
firstAllocatable = list.size() > 0 ? list.get(0) : null;
Set<Permission> permissions = new LinkedHashSet<Permission>();
for (Allocatable allocatable :list)
{
List<Permission> permissionList = Arrays.asList(allocatable.getPermissions());
permissions.addAll(permissionList);
}
Set<Permission> set = new LinkedHashSet<Permission>();
for (Permission perm : permissions) {
model.addElement(perm);
for (Allocatable allocatable:list)
{
List<Permission> asList = Arrays.asList(allocatable.getPermissions());
if (!asList.contains(perm))
{
set.add( perm);
}
}
}
notAllList.clear();
for (Permission perm : set)
{
notAllList.add(perm);
}
listEdit.setListDimension(new Dimension(210, 90));
listEdit.setMoveButtonVisible(false);
listEdit.getList().setModel(model);
listEdit.getList().setCellRenderer(new DefaultListCellRenderer() {
private static final long serialVersionUID = 1L;
public Component getListCellRendererComponent(JList list,
Object value, int index, boolean isSelected,
boolean cellHasFocus) {
Permission p = (Permission) value;
if (p.getUser() != null) {
value = getString("user") + " " + p.getUser().getUsername();
} else if (p.getGroup() != null) {
value = getString("group") + " "
+ p.getGroup().getName(getI18n().getLocale());
} else {
value = getString("all_users");
}
value = (index + 1) + ") " + value;
Component component = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
Font f;
if (isNotForAll( p))
{
f =component.getFont().deriveFont(Font.ITALIC);
}
else
{
f =component.getFont().deriveFont(Font.BOLD);
}
component.setFont(f);
return component;
}
});
}
// Check if permission is in notAllList. We need to check references as the equals method could also match another permission
private boolean isNotForAll( Permission p) {
for (Permission perm: notAllList)
{
if ( perm == p)
{
return true;
}
}
return false;
}
private void removePermission() {
for (Permission permission:listEdit.getSelectedValues())
{
model.removeElement(permission);
}
listEdit.getList().requestFocus();
}
@SuppressWarnings("unchecked")
private void createPermission() {
if ( firstAllocatable == null)
{
return;
}
Permission permission = firstAllocatable.newPermission();
model.addElement(permission);
}
class Listener implements ActionListener, ChangeListener {
public void actionPerformed(ActionEvent evt) {
if (evt.getActionCommand().equals("remove")) {
removePermission();
} else if (evt.getActionCommand().equals("new")) {
createPermission();
} else if (evt.getActionCommand().equals("edit")) {
// buffer selected Permission
selectedPermission = (Permission) listEdit.getList().getSelectedValue();
selectedIndex = listEdit.getList().getSelectedIndex();
// commit common Permissions (like the selected one) for
// processing
permissionField.setValue(selectedPermission);
}
}
@SuppressWarnings("unchecked")
public void stateChanged(ChangeEvent evt) {
// set processed selected Permission in the list
model.set(selectedIndex, selectedPermission);
// remove permission from notAllList we need to check references as the equals method could also match another permission
Iterator<Permission> it = notAllList.iterator();
while (it.hasNext())
{
Permission next = it.next();
if ( next == selectedPermission )
{
it.remove();
}
}
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Collection;
import javax.swing.AbstractCellEditor;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.table.DefaultTableModel;
import org.rapla.entities.MultiLanguageName;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.RaplaButton;
public class MultiLanguageField extends AbstractEditField implements ChangeListener, ActionListener,CellEditorListener, SetGetField<MultiLanguageName> {
JPanel panel = new JPanel();
TextField textField;
RaplaButton button = new RaplaButton(RaplaButton.SMALL);
MultiLanguageName name = new MultiLanguageName();
MultiLanguageEditorDialog editorDialog;
String[] availableLanguages;
public MultiLanguageField(RaplaContext context, String fieldName)
{
this(context);
setFieldName(fieldName);
}
public MultiLanguageField(RaplaContext context)
{
super( context);
textField = new TextField(context, "name");
availableLanguages = getRaplaLocale().getAvailableLanguages();
panel.setLayout( new BorderLayout() );
panel.add( textField.getComponent(), BorderLayout.CENTER );
panel.add( button, BorderLayout.EAST );
button.addActionListener( this );
button.setIcon( getIcon("icon.language-select") );
textField.addChangeListener( this );
}
public void requestFocus() {
textField.getComponent().requestFocus();
}
public void selectAll()
{
textField.selectAll();
}
public void stateChanged(ChangeEvent e) {
if (name != null) {
name.setName(getI18n().getLang(),textField.getValue());
fireContentChanged();
}
}
public void actionPerformed(ActionEvent evt) {
editorDialog = new MultiLanguageEditorDialog( button );
editorDialog.addCellEditorListener( this );
editorDialog.setEditorValue( name );
try {
editorDialog.show();
} catch (RaplaException ex) {
showException( ex, getComponent());
}
}
public void editingStopped(ChangeEvent e) {
setValue((MultiLanguageName) editorDialog.getEditorValue());
fireContentChanged();
}
public void editingCanceled(ChangeEvent e) {
}
public MultiLanguageName getValue() {
return this.name;
}
public void setValue(MultiLanguageName object) {
this.name = object;
textField.setValue(name.getName(getI18n().getLang()));
}
public JComponent getComponent() {
return panel;
}
class MultiLanguageEditorDialog extends AbstractCellEditor {
private static final long serialVersionUID = 1L;
JTable table = new JTable();
JLabel label = new JLabel();
JPanel comp = new JPanel();
MultiLanguageName editorValue;
Component owner;
MultiLanguageEditorDialog(JComponent owner) {
this.owner = owner;
table.setPreferredScrollableViewportSize(new Dimension(300, 200));
comp.setLayout(new BorderLayout());
comp.add(label,BorderLayout.NORTH);
comp.add(new JScrollPane(table),BorderLayout.CENTER);
}
public void setEditorValue(Object value) {
this.editorValue = (MultiLanguageName)value;
table.setModel(new TranslationTableModel(editorValue));
table.getColumnModel().getColumn(0).setPreferredWidth(30);
table.getColumnModel().getColumn(1).setPreferredWidth(200);
label.setText(getI18n().format("translation.format", editorValue));
}
public Object getEditorValue() {
return editorValue;
}
public Object getCellEditorValue() {
return getEditorValue();
}
public void show() throws RaplaException {
DialogUI dlg = DialogUI.create(getContext(),owner,true,comp,new String[] { getString("ok"),getString("cancel")});
dlg.setTitle(getString("translation"));
// Workaround for Bug ID 4480264 on developer.java.sun.com
if (table.getRowCount() > 0 ) {
table.editCellAt(0, 0);
table.editCellAt(0, 1);
}
dlg.start();
if (dlg.getSelectedIndex() == 0) {
for (int i=0;i<availableLanguages.length;i++) {
String value = (String)table.getValueAt(i,1);
if (value != null)
editorValue.setName(availableLanguages[i],value);
}
if (table.isEditing()) {
if (table.getEditingColumn() == 1) {
JTextField textField = (JTextField) table.getEditorComponent();
addCopyPaste( textField);
int row = table.getEditingRow();
String value = textField.getText();
editorValue.setName(availableLanguages[row],value);
}
}
fireEditingStopped();
} else {
fireEditingCanceled();
}
}
}
class TranslationTableModel extends DefaultTableModel {
private static final long serialVersionUID = 1L;
public TranslationTableModel(MultiLanguageName name) {
super();
addColumn(getString("language"));
addColumn(getString("translation"));
Collection<String> trans = name.getAvailableLanguages();
for (int i=0;i<availableLanguages.length;i++) {
String lang = availableLanguages[i];
String[] row = new String[2];
row[0] = lang;
row[1] = trans.contains(lang) ? name.getName(lang): "";
addRow(row);
}
}
public boolean isCellEditable(int row, int col) {
//Note that the data/cell address is constant,
//no matter where the cell appears onscreen.
if (col < 1) {
return false;
} else {
return true;
}
}
}
}
| Java |
package org.rapla.gui.internal.edit.fields;
//Interface for one EditField; it is designed for showing multiple values at the same time
public interface MultiEditField {
// shows the field a place holder for different values or a common value for all objects?
public boolean hasMultipleValues();
// sets on a field a place holder for different values
public void setFieldForMultipleValues();
} | Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import org.rapla.framework.RaplaContext;
public class BooleanField extends AbstractEditField implements ActionListener, FocusListener, MultiEditField, SetGetField<Boolean>
{
JPanel panel = new JPanel();
JRadioButton field1 = new JRadioButton();
JRadioButton field2 = new JRadioButton();
ButtonGroup group = new ButtonGroup();
boolean multipleValues; // indicator, shows if multiple different values are
// shown in this field
JLabel multipleValuesLabel = new JLabel();
public BooleanField(RaplaContext context,String fieldName)
{
this(context);
setFieldName( fieldName );
}
public BooleanField(RaplaContext context)
{
super( context);
field1.setOpaque( false );
field2.setOpaque( false );
panel.setOpaque( false );
panel.setLayout( new BoxLayout(panel,BoxLayout.X_AXIS) );
panel.add( field1 );
panel.add( field2 );
panel.add(multipleValuesLabel);
group.add( field1 );
group.add( field2 );
field2.setSelected( true );
field1.addActionListener(this);
field2.addActionListener(this);
field1.setText(getString("yes"));
field2.setText(getString("no"));
field1.addFocusListener(this);
}
public Boolean getValue() {
return field1.isSelected() ? Boolean.TRUE : Boolean.FALSE;
}
public void setValue(Boolean object) {
boolean selected = object!= null ? (object).booleanValue() :false;
field1.setSelected(selected);
field2.setSelected(!selected);
}
public void actionPerformed(ActionEvent evt) {
// once an action is executed, the field shows a common value
multipleValues = false;
multipleValuesLabel.setText("");
fireContentChanged();
}
public JComponent getComponent() {
return panel;
}
public void focusGained(FocusEvent evt) {
Component focusedComponent = evt.getComponent();
Component parent = focusedComponent.getParent();
if(parent instanceof JPanel) {
((JPanel)parent).scrollRectToVisible(focusedComponent.getBounds(null));
}
}
public void focusLost(FocusEvent evt) {
}
public void setFieldForMultipleValues() {
// if multiple different values should be shown, no RadioButton is
// activated (instead a place holder)
group.clearSelection();
multipleValues = true;
multipleValuesLabel.setText(TextField.getOutputForMultipleValues());
multipleValuesLabel.setFont(multipleValuesLabel.getFont().deriveFont(Font.ITALIC));
}
public boolean hasMultipleValues() {
return multipleValues;
}
} | Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.util.Arrays;
import java.util.Set;
import java.util.TreeSet;
import org.rapla.entities.NamedComparator;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
public class AllocatableListField extends ListField<Allocatable> {
DynamicType dynamicTypeConstraint;
public AllocatableListField(RaplaContext context, DynamicType dynamicTypeConstraint) throws RaplaException{
super( context, true);
this.dynamicTypeConstraint = dynamicTypeConstraint;
ClassificationFilter filter = dynamicTypeConstraint.newClassificationFilter();
ClassificationFilter[] filters = new ClassificationFilter[] {filter};
Allocatable[] allocatables = getQuery().getAllocatables(filters);
Set<Allocatable> list = new TreeSet<Allocatable>(new NamedComparator<Allocatable>(getLocale()));
list.addAll( Arrays.asList( allocatables));
setVector(list);
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.util.Date;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import org.rapla.components.calendar.DateChangeEvent;
import org.rapla.components.calendar.DateChangeListener;
import org.rapla.components.calendar.RaplaCalendar;
import org.rapla.framework.RaplaContext;
public class DateField extends AbstractEditField implements DateChangeListener, FocusListener, SetGetField<Date> ,MultiEditField{
RaplaCalendar field;
JPanel panel;
boolean multipleValues = false; // Indikator, ob mehrere verschiedene Werte ueber dieses Feld angezeigt werden
JLabel multipleValuesLabel = new JLabel();
public DateField(RaplaContext context,String fieldName) {
this( context);
setFieldName(fieldName);
}
public DateField(RaplaContext context) {
super( context);
panel = new JPanel();
field = createRaplaCalendar();
panel.setLayout(new BorderLayout());
panel.add(field,BorderLayout.WEST);
panel.add( multipleValuesLabel, BorderLayout.CENTER);
panel.setOpaque( false );
field.setNullValuePossible( true);
field.addDateChangeListener(this);
field.addFocusListener(this);
}
public Date getValue() {
return field.getDate();
}
public void setValue(Date date) {
// //check if standard-value exists and is a Date-Object
// if(object instanceof Date)
// date = (Date) object;
// //if it's not a Date-Object, set the current Date as Standart
// else
// date = new Date();
field.setDate(date);
}
public RaplaCalendar getCalendar() {
return field;
}
public void dateChanged(DateChangeEvent evt) {
// Eingabe wurde getaetigt: einheitlicher Werte wurde gesetzt => Flag aendern, da kein Platzhalter mehr angezeigt wird
if(multipleValues){
multipleValues = false;
}
fireContentChanged();
}
public JComponent getComponent() {
return panel;
}
public void focusGained(FocusEvent evt) {
Component focusedComponent = evt.getComponent();
Component parent = focusedComponent.getParent();
if(parent instanceof JPanel) {
((JPanel)parent).scrollRectToVisible(focusedComponent.getBounds(null));
}
}
public void focusLost(FocusEvent evt) {
}
// Implementierung fuer Interface MultiEditField
public boolean hasMultipleValues() {
return multipleValues;
}
// Implementierung fuer Interface MultiEditField
public void setFieldForMultipleValues() {
multipleValues = true;
multipleValuesLabel.setText(TextField.getOutputForMultipleValues());
multipleValuesLabel.setFont(multipleValuesLabel.getFont().deriveFont(Font.ITALIC));
field.setDate( null);
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import org.rapla.gui.EditField;
public interface SetGetField<T> extends EditField
{
T getValue();
void setValue(T value);
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit.fields;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import javax.swing.AbstractAction;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.plaf.basic.BasicTreeUI;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeSelectionModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
import org.rapla.components.util.Tools;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.TreeFactory;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.RaplaButton;
import org.rapla.gui.toolkit.RaplaTree.TreeIterator;
public abstract class AbstractSelectField<T> extends AbstractEditField implements MultiEditField, SetGetField<T>, SetGetCollectionField<T>
{
private RaplaButton selectButton = new RaplaButton(RaplaButton.SMALL);
JPanel panel = new JPanel();
JLabel selectText = new JLabel();
private Collection<T> selectedValues = new ArrayList<T>();
T defaultValue;
private boolean useDefault = true;
private boolean useNull = true;
boolean multipleValues = false;
boolean multipleSelectionPossible = false;
public RaplaButton getButton() {
return selectButton;
}
public AbstractSelectField(RaplaContext context){
this( context, null);
}
public AbstractSelectField(RaplaContext context, T defaultValue) {
super( context);
useDefault = defaultValue != null;
selectButton.setAction(new SelectionAction());
selectButton.setHorizontalAlignment(RaplaButton.LEFT);
selectButton.setText(getString("select"));
selectButton.setIcon(getIcon("icon.tree"));
panel.setLayout( new BoxLayout(panel, BoxLayout.X_AXIS));
panel.add( selectButton);
panel.add( Box.createHorizontalStrut(10));
panel.add( selectText);
this.defaultValue = defaultValue;
}
public boolean isUseNull()
{
return useNull;
}
public void setUseNull(boolean useNull)
{
this.useNull = useNull;
}
public boolean isMultipleSelectionPossible() {
return multipleSelectionPossible;
}
public void setMultipleSelectionPossible(boolean multipleSelectionPossible) {
this.multipleSelectionPossible = multipleSelectionPossible;
}
public class SelectionAction extends AbstractAction
{
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent evt) {
try {
showDialog(selectButton);
} catch (RaplaException ex) {
showException(ex,selectButton);
}
}
}
public T getValue()
{
Collection<T> values = getValues();
if ( values.size() == 0)
{
return null;
}
else
{
T first = values.iterator().next();
return first;
}
}
public Collection<T> getValues()
{
return selectedValues;
}
public void setValue(T object)
{
List<T> list;
if ( object == null)
{
list = Collections.emptyList();
}
else
{
list = Collections.singletonList(object);
}
setValues(list);
}
final protected TreeFactory getTreeFactory()
{
return getService(TreeFactory.class);
}
public void setValues(Collection<T> values)
{
selectedValues = new ArrayList<T>();
if ( values !=null)
{
selectedValues.addAll(values);
}
String text;
if (selectedValues.size() > 0)
{
text="";
T selectedCategory = selectedValues.iterator().next();
{
text +=getNodeName(selectedCategory);
}
if ( selectedValues.size() > 1)
{
text+= ", ...";
}
}
else
{
text = getString("nothing_selected");
}
selectText.setText(text);
}
protected abstract String getNodeName(T selectedCategory);
public class MultiSelectionTreeUI extends BasicTreeUI
{
@Override
protected boolean isToggleSelectionEvent( MouseEvent event )
{
return SwingUtilities.isLeftMouseButton( event );
}
}
@SuppressWarnings("serial")
public void showDialog(JComponent parent) throws RaplaException {
final DialogUI dialog;
final JTree tree;
if ( multipleSelectionPossible)
{
tree = new JTree()
{
public void setSelectionPath(TreePath path) {
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
StackTraceElement caller = stackTrace[2];
String className = caller.getClassName();
String methodName = caller.getMethodName();
if ( className.contains("BasicTreeUI") && (methodName.contains("keyTyped") || methodName.contains("page")))
{
setLeadSelectionPath( path);
return;
}
setSelectionPath(path);
}
public void setSelectionInterval(int index0, int index1) {
if ( index0 >= 0)
{
TreePath path = getPathForRow(index0);
setLeadSelectionPath( path);
}
}
};
TreeSelectionModel model = new DefaultTreeSelectionModel();
tree.setUI( new MultiSelectionTreeUI() );
model.setSelectionMode( TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION );
tree.setSelectionModel(model );
}
else
{
tree = new JTree();
tree.getSelectionModel().setSelectionMode( TreeSelectionModel.SINGLE_TREE_SELECTION );
}
tree.setCellRenderer(getTreeFactory().createRenderer());
//tree.setVisibleRowCount(15);
tree.setRootVisible( false );
tree.setShowsRootHandles(true);
TreeModel model = createModel();
tree.setModel(model);
selectCategory(tree,selectedValues);
JPanel panel = new JPanel();
panel.setLayout( new BorderLayout());
JScrollPane scrollPane = new JScrollPane(tree);
scrollPane.setMinimumSize(new Dimension(300, 200));
scrollPane.setPreferredSize(new Dimension(400, 260));
panel.add(scrollPane, BorderLayout.PAGE_START);
if (useDefault)
{
JButton defaultButton = new JButton(getString("defaultselection"));
panel.add( defaultButton, BorderLayout.CENTER);
defaultButton.setPreferredSize(new Dimension(100, 20));
defaultButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent arg0)
{
selectCategory( tree, Collections.singletonList(defaultValue));
}
});
}
if (useNull)
{
JButton emptyButton = new JButton(getString("nothing_selected"));
panel.add( emptyButton, BorderLayout.PAGE_END);
emptyButton.setPreferredSize(new Dimension(100, 20));
emptyButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent arg0)
{
List<T> emptyList = Collections.emptyList();
selectCategory(tree, emptyList );
}
});
}
dialog = DialogUI.create(getContext()
,parent
,true
,panel
,new String[] { getString("apply"),getString("cancel")});
tree.addMouseListener(new MouseAdapter() {
// End dialog when a leaf is double clicked
public void mousePressed(MouseEvent e) {
TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
if (selPath != null && e.getClickCount() == 2) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode)selPath.getLastPathComponent();
if (node.isLeaf()) {
dialog.getButton(0).doClick();
}
}
}
});
dialog.setTitle(getString("select"));
dialog.setInitFocus( tree);
dialog.start();
if (dialog.getSelectedIndex() == 0) {
TreePath[] paths = tree.getSelectionPaths();
Collection<T> newValues = new ArrayList<T>();
if ( paths != null)
{
for (TreePath path:paths)
{
Object valueObject = ((DefaultMutableTreeNode)path.getLastPathComponent()).getUserObject();
T value = getValue(valueObject);
if ( value != null)
{
newValues.add(value);
}
}
}
if ( !newValues.equals(selectedValues))
{
setValues( newValues );
fireContentChanged();
}
}
}
protected T getValue(Object valueObject) {
@SuppressWarnings("unchecked")
T casted = (T) valueObject;
return casted;
}
public abstract TreeModel createModel() throws RaplaException;
private void selectCategory(JTree tree, Collection<T> categories) {
select(tree, categories);
//RecursiveNode.selectUserObjects(tree,path.toArray());
}
public void select(JTree jTree,Collection<?> selectedObjects) {
Collection<TreeNode> selectedNodes = new ArrayList<TreeNode>();
Iterator<TreeNode> it = new TreeIterator((TreeNode)jTree.getModel().getRoot());
while (it.hasNext()) {
TreeNode node = it.next();
if (node != null && selectedObjects.contains( getObject(node) ))
selectedNodes.add(node);
}
it = selectedNodes.iterator();
TreePath[] path = new TreePath[selectedNodes.size()];
int i=0;
while (it.hasNext()) {
path[i] = getPath(it.next());
jTree.expandPath(path[i]);
i++;
}
jTree.getSelectionModel().clearSelection();
jTree.setSelectionPaths(path);
}
private static Object getObject(Object treeNode) {
try {
if (treeNode == null)
return null;
if (treeNode instanceof DefaultMutableTreeNode)
return ((DefaultMutableTreeNode) treeNode).getUserObject();
return treeNode.getClass().getMethod("getUserObject",Tools.EMPTY_CLASS_ARRAY).invoke(treeNode, Tools.EMPTY_ARRAY);
} catch (Exception ex) {
return null;
}
}
private TreePath getPath(TreeNode node) {
if (node.getParent() == null)
return new TreePath(node);
else
return getPath(node.getParent()).pathByAddingChild(node);
}
public JComponent getComponent() {
return panel;
}
// implementation for interface MultiEditField
public boolean hasMultipleValues() {
return multipleValues;
}
// implementation for interface MultiEditField
public void setFieldForMultipleValues() {
multipleValues = true;
// sets place holder for different values
selectText.setText(TextField.getOutputForMultipleValues());
}
}
| Java |
package org.rapla.gui.internal.edit.fields;
public class EditFieldLayout
{
private boolean block;
private boolean variableSized;
public boolean isBlock() {
return block;
}
public void setBlock(boolean block) {
this.block = block;
}
public boolean isVariableSized() {
return variableSized;
}
public void setVariableSized(boolean variableSized) {
this.variableSized = variableSized;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit;
import java.awt.Component;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.rapla.entities.Category;
import org.rapla.entities.Entity;
import org.rapla.entities.RaplaType;
import org.rapla.entities.User;
import org.rapla.entities.configuration.Preferences;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Reservation;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.entities.dynamictype.DynamicTypeAnnotations;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.EditComponent;
import org.rapla.gui.EditController;
import org.rapla.gui.RaplaGUIComponent;
/** This class handles the edit-ui for all entities (except reservations). */
public class EditControllerImpl extends RaplaGUIComponent implements
EditController {
Collection<EditDialog<?>> editWindowList = new ArrayList<EditDialog<?>>();
public EditControllerImpl(RaplaContext sm){
super(sm);
}
void addEditDialog(EditDialog<?> editWindow) {
editWindowList.add(editWindow);
}
void removeEditDialog(EditDialog<?> editWindow) {
editWindowList.remove(editWindow);
}
public <T extends Entity> EditComponent<T> createUI(T obj) throws RaplaException
{
return createUI( obj,false);
}
/*
* (non-Javadoc)
*
* @see org.rapla.gui.edit.IEditController#createUI(org.rapla.entities.
* RaplaPersistant)
*/
@SuppressWarnings("unchecked")
public <T extends Entity> EditComponent<T> createUI(T obj, boolean createNew) throws RaplaException {
RaplaType type = obj.getRaplaType();
EditComponent<?> ui = null;
if (Allocatable.TYPE.equals(type)) {
boolean internal = isInternalType( (Allocatable)obj);
ui = new AllocatableEditUI(getContext(), internal);
} else if (DynamicType.TYPE.equals(type)) {
ui = new DynamicTypeEditUI(getContext());
} else if (User.TYPE.equals(type)) {
ui = new UserEditUI(getContext());
} else if (Category.TYPE.equals(type)) {
ui = new CategoryEditUI(getContext(), createNew);
} else if (Preferences.TYPE.equals(type)) {
ui = new PreferencesEditUI(getContext());
} else if (Reservation.TYPE.equals(type)) {
ui = new ReservationEditUI(getContext());
}
if (ui == null) {
throw new RuntimeException("Can't edit objects of type "
+ type.toString());
}
return (EditComponent<T>)ui;
}
private boolean isInternalType(Allocatable alloc) {
DynamicType type = alloc.getClassification().getType();
String annotation = type.getAnnotation(DynamicTypeAnnotations.KEY_CLASSIFICATION_TYPE);
return annotation != null && annotation.equals( DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RAPLATYPE);
}
// enhancement of the method to deal with arrays
protected String guessTitle(Object obj) {
RaplaType raplaType = getRaplaType(obj);
String title = "";
if(raplaType != null) {
title = getString(raplaType.getLocalName());
}
return title;
}
// method for determining the consistent RaplaType from different objects
protected RaplaType getRaplaType(Object obj){
Set<RaplaType> types = new HashSet<RaplaType>();
// if the committed object is no array -> wrap object into array
if (!obj.getClass().isArray()) {
obj = new Object[] { obj };
}
// iterate all committed objects and store RaplayType of the objects in a Set
// identic typs aren't stored double because of Set
for (Object o : (Object[]) obj) {
if (o instanceof Entity) {
RaplaType type = ((Entity<?>) o).getRaplaType();
types.add(type);
}
}
// check if there is a explicit type, then return this type; otherwise return null
if (types.size() == 1)
return types.iterator().next();
else
return null;
}
public <T extends Entity> void edit(T obj, Component owner) throws RaplaException {
edit(obj, guessTitle(obj), owner);
}
public <T extends Entity> void editNew(T obj, Component owner)
throws RaplaException {
edit(obj, guessTitle(obj), owner, true);
}
public <T extends Entity> void edit(T[] obj, Component owner) throws RaplaException {
edit(obj, guessTitle(obj), owner);
}
/*
* (non-Javadoc)
*
* @see org.rapla.gui.edit.IEditController#edit(org.rapla.entities.Entity,
* java.lang.String, java.awt.Component)
*/
public <T extends Entity> void edit(T obj, String title, Component owner)
throws RaplaException {
edit(obj, title, owner, false);
}
protected <T extends Entity> void edit(T obj, String title, Component owner,boolean createNew )
throws RaplaException {
// Hack for 1.6 compiler compatibility
@SuppressWarnings("cast")
Entity<?> testObj = (Entity<?>) obj;
if ( testObj instanceof Reservation)
{
getReservationController().edit( (Reservation) testObj );
return;
}
// Lookup if the reservation is already beeing edited
EditDialog<?> c = null;
Iterator<EditDialog<?>> it = editWindowList.iterator();
while (it.hasNext()) {
c = it.next();
List<?> editObj = c.ui.getObjects();
if (editObj != null && editObj.size() == 1 )
{
Object first = editObj.get(0);
if (first instanceof Entity && ((Entity<?>) first).isIdentical(obj))
{
break;
}
}
c = null;
}
if (c != null) {
c.dlg.requestFocus();
c.dlg.toFront();
} else {
editAndOpenDialog( Collections.singletonList( obj),title, owner, createNew);
}
}
// method analog to edit(Entity obj, String title, Component owner)
// however for using with arrays
public <T extends Entity> void edit(T[] obj, String title, Component owner)
throws RaplaException {
// checks if all entities are from the same type; otherwise return
if(getRaplaType(obj) == null) return;
// if selektion contains only one object start usual Edit dialog
if(obj.length == 1){
edit(obj[0], title, owner);
}
else
{
editAndOpenDialog(Arrays.asList(obj), title, owner, false);
}
}
protected <T extends Entity> void editAndOpenDialog(List<T> list, String title, Component owner, boolean createNew) throws RaplaException {
// gets for all objects in array a modifiable version and add it to a set to avoid duplication
Collection<T> toEdit = getModification().edit( list);
if (toEdit.size() > 0) {
EditComponent<T> ui = createUI(toEdit.iterator().next(), createNew);
EditDialog<T> gui = new EditDialog<T>(getContext(), ui, false);
gui.start(toEdit, title, owner);
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.rapla.components.util.Assert;
import org.rapla.entities.Category;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.AttributeAnnotations;
import org.rapla.entities.dynamictype.AttributeType;
import org.rapla.entities.dynamictype.Classification;
import org.rapla.entities.dynamictype.ConstraintIds;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.EditField;
import org.rapla.gui.internal.edit.fields.AllocatableSelectField;
import org.rapla.gui.internal.edit.fields.BooleanField;
import org.rapla.gui.internal.edit.fields.CategoryListField;
import org.rapla.gui.internal.edit.fields.CategorySelectField;
import org.rapla.gui.internal.edit.fields.DateField;
import org.rapla.gui.internal.edit.fields.LongField;
import org.rapla.gui.internal.edit.fields.MultiEditField;
import org.rapla.gui.internal.edit.fields.SetGetCollectionField;
import org.rapla.gui.internal.edit.fields.SetGetField;
import org.rapla.gui.internal.edit.fields.TextField;
public class ClassificationEditUI extends AbstractEditUI<Classification> {
public ClassificationEditUI(RaplaContext sm) {
super(sm);
}
// enhanced to an array, for administration of multiple classifications
private String getAttName(String key) {
// collection of all attribute-names for the deposited classifications
Set<String> attNames = new HashSet<String>();
for (Classification c : objectList) {
attNames.add(getName(c.getAttribute(key)));
}
// checks if there is a common attribute-name
if (attNames.size() == 1) {
// delivers this name
return attNames.iterator().next();
} else {
return "-";
}
}
protected Attribute getAttribute(int i) {
// collection of all attributes for the deposited classifications for a
// certain field
Set<Attribute> attributes = new HashSet<Attribute>();
for (Classification c : objectList) {
String key = getKey( fields.get(i));
Attribute attribute = c.getAttribute(key);
attributes.add(attribute);
}
// check if there is a common attribute
if (attributes.size() == 1) {
// delivers this attribute
return attributes.iterator().next();
} else {
return null;
}
}
protected void setAttValue(String key, Object value) {
// sets the attribute value for all deposited classifications
for (Classification c : objectList) {
Attribute attribute = c.getAttribute(key);
if ( value instanceof Collection<?>)
{
Collection<?> collection = (Collection<?>)value;
Boolean multiSelect = (Boolean)attribute.getConstraint(ConstraintIds.KEY_MULTI_SELECT);
if ( multiSelect != null && multiSelect==true)
{
c.setValues(attribute, collection);
}
else if ( collection.size() > 0)
{
c.setValue(attribute, collection.iterator().next());
}
else
{
c.setValue(attribute, null);
}
}
else
{
c.setValue(attribute, value);
}
}
}
public Set<Object> getUniqueAttValues(String key) {
// collection of all attribute values for a certain attribute
Set<Object> values = new LinkedHashSet<Object>();
for (Classification c : objectList) {
Attribute attribute = c.getAttribute(key);
Object value;
Boolean multiSelect = (Boolean) attribute.getConstraint(ConstraintIds.KEY_MULTI_SELECT);
if ( multiSelect != null && multiSelect == true)
{
value = c.getValues(attribute);
}
else
{
value = c.getValue(attribute);
}
values.add(value);
}
return values;
}
private SetGetField<?> createField(Attribute attribute) {
AttributeType type = attribute.getType();
String label = getAttName(attribute.getKey());
SetGetField<?> field = null;
RaplaContext context = getContext();
if (type.equals(AttributeType.STRING)) {
Integer rows = new Integer(attribute.getAnnotation( AttributeAnnotations.KEY_EXPECTED_ROWS, "1"));
Integer columns = new Integer(attribute.getAnnotation( AttributeAnnotations.KEY_EXPECTED_COLUMNS,String.valueOf(TextField.DEFAULT_LENGTH)));
field = new TextField(context, label, rows.intValue(),columns.intValue());
} else if (type.equals(AttributeType.INT)) {
field = new LongField(context, label);
} else if (type.equals(AttributeType.DATE)) {
field = new DateField(context, label);
} else if (type.equals(AttributeType.BOOLEAN)) {
field = new BooleanField(context, label);
} else if (type.equals(AttributeType.ALLOCATABLE)) {
DynamicType dynamicTypeConstraint = (DynamicType)attribute.getConstraint( ConstraintIds.KEY_DYNAMIC_TYPE);
Boolean multipleSelectionPossible = (Boolean) attribute.getConstraint(ConstraintIds.KEY_MULTI_SELECT);
// if (dynamicTypeConstraint == null || multipleSelectionPossible) {
AllocatableSelectField allocField = new AllocatableSelectField(context, dynamicTypeConstraint);
allocField.setFieldName(label);
allocField.setMultipleSelectionPossible( multipleSelectionPossible != null ? multipleSelectionPossible : false);
field = allocField;
// }else {
// AllocatableListField allocField = new AllocatableListField(context, key, dynamicTypeConstraint);
// field = allocField;
// }
} else if (type.equals(AttributeType.CATEGORY)) {
Category defaultCategory = (Category) attribute.defaultValue();
Category rootCategory = (Category) attribute.getConstraint(ConstraintIds.KEY_ROOT_CATEGORY);
boolean multipleSelectionPossible = attribute.getAnnotation(ConstraintIds.KEY_MULTI_SELECT, "false").equals("true");
if (rootCategory.getDepth() > 2 || multipleSelectionPossible) {
CategorySelectField catField = new CategorySelectField(context, rootCategory, defaultCategory);
catField.setMultipleSelectionPossible( multipleSelectionPossible);
catField.setFieldName( label );
field = catField;
} else {
CategoryListField catField = new CategoryListField(context, rootCategory);
catField.setFieldName( label );
field = catField;
}
}
Assert.notNull(field, "Unknown AttributeType");
return field;
}
Map<EditField,String> fieldKeyMap = new HashMap<EditField,String>();
public void setObjects(List<Classification> classificationList) throws RaplaException {
this.objectList = classificationList;
// determining of the DynmicTypes from the classifications
Set<DynamicType> types = new HashSet<DynamicType>();
for (Classification c : objectList) {
types.add(c.getType());
}
// checks if there is a common DynmicType
if (types.size() == 1) {
fieldKeyMap.clear();
// read out attributes for this DynmicType
Attribute[] attributes = types.iterator().next().getAttributes();
// create fields for attributes
List<SetGetField<?>> fields= new ArrayList<SetGetField<?>>();
for (Attribute attribute:attributes) {
SetGetField<?> field = createField(attribute);
//field.setUser(classificationList);
fields.add( field);
fieldKeyMap.put( field, attribute.getKey());
}
// show fields
setFields(fields);
}
mapFromObjects();
}
public void mapTo(SetGetField<?> field) {
// checks if the EditField shows a common value
if (field instanceof MultiEditField && ((MultiEditField) field).hasMultipleValues())
return;
// read out attribute value if the field shows a common value
String attKey = getKey(field);
if ( field instanceof SetGetCollectionField)
{
Collection<?> values = ((SetGetCollectionField<?>) field).getValues();
setAttValue(attKey, values);
}
else
{
setAttValue(attKey, field.getValue());
}
}
protected String getKey(EditField field)
{
String key = fieldKeyMap.get( field);
return key;
}
public <T> void mapFrom(SetGetField<T> field ) {
// read out attribute values
Set<Object> values = getUniqueAttValues(getKey(field));
// checks if there is a common value, otherwise a place holder has
// to be shown for this field
if ( values.size() > 1 && field instanceof MultiEditField)
{
// shows place holder
((MultiEditField) field).setFieldForMultipleValues();
}
else if ( values.size() == 1)
{
// set common value
Object first = values.iterator().next();
if ( first instanceof Collection)
{
@SuppressWarnings("unchecked")
Collection<T> list = (Collection<T>)first;
if ( field instanceof SetGetCollectionField)
{
@SuppressWarnings("unchecked")
SetGetCollectionField<T> setGetCollectionField = (SetGetCollectionField<T>)field;
setGetCollectionField.setValues(list);
}
else if ( list.size() > 0)
{
field.setValue( list.iterator().next());
}
else
{
field.setValue( null);
}
}
else
{
@SuppressWarnings("unchecked")
T casted = (T)first;
field.setValue( casted);
}
}
else
{
field.setValue(null);
}
}
public void mapToObjects() throws RaplaException
{
for (EditField field: fields)
{
SetGetField<?> f = (SetGetField<?>) field;
mapTo( f);
}
}
protected void mapFromObjects() throws RaplaException {
for (EditField field: fields)
{
SetGetField<?> f = (SetGetField<?>) field;
mapFrom( f);
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import org.rapla.components.calendar.RaplaArrowButton;
import org.rapla.components.layout.TableLayout;
import org.rapla.components.util.Tools;
import org.rapla.entities.Category;
import org.rapla.entities.CategoryAnnotations;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.EditComponent;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.TreeFactory;
import org.rapla.gui.internal.edit.fields.MultiLanguageField;
import org.rapla.gui.internal.edit.fields.TextField;
import org.rapla.gui.internal.view.TreeFactoryImpl.NamedNode;
import org.rapla.gui.toolkit.RaplaButton;
import org.rapla.gui.toolkit.RaplaTree;
/**
* @author Christopher Kohlhaas
*/
public class CategoryEditUI extends RaplaGUIComponent
implements
EditComponent<Category>
{
JPanel panel = new JPanel();
JPanel toolbar = new JPanel();
RaplaButton newButton = new RaplaButton();
RaplaButton newSubButton = new RaplaButton();
RaplaButton removeButton = new RaplaButton();
RaplaArrowButton moveUpButton = new RaplaArrowButton('^', 25);
RaplaArrowButton moveDownButton = new RaplaArrowButton('v', 25);
Category rootCategory;
CategoryDetail detailPanel;
RaplaTreeEdit treeEdit;
TreeModel model;
boolean editKeys = true;
Listener listener = new Listener();
TreeCellRenderer iconRenderer;
boolean createNew;
public CategoryEditUI(RaplaContext context, boolean createNew) {
super( context);
this.createNew = createNew;
detailPanel = new CategoryDetail(context);
panel.setPreferredSize( new Dimension( 690,350 ) );
treeEdit = new RaplaTreeEdit( getI18n(),detailPanel.getComponent(), listener );
treeEdit.setListDimension( new Dimension( 250,100 ) );
toolbar.setLayout( new BoxLayout(toolbar, BoxLayout.X_AXIS));
toolbar.add(newButton);
toolbar.add(newSubButton);
toolbar.add( Box.createHorizontalStrut( 5 ));
toolbar.add(removeButton);
toolbar.add( Box.createHorizontalStrut( 5 ));
toolbar.add(moveUpButton);
toolbar.add(moveDownButton);
panel.setLayout( new BorderLayout() );
panel.add( toolbar, BorderLayout.NORTH );
panel.add( treeEdit.getComponent(), BorderLayout.CENTER );
newButton.addActionListener(listener);
newSubButton.addActionListener(listener);
removeButton.addActionListener(listener);
moveUpButton.addActionListener( listener );
moveDownButton.addActionListener( listener );
iconRenderer = getTreeFactory().createRenderer();
treeEdit.getTree().setCellRenderer( new TreeCellRenderer() {
public Component getTreeCellRendererComponent(JTree tree
,Object value
,boolean sel
,boolean expanded
,boolean leaf
,int row
,boolean hasFocus
) {
if ( value instanceof NamedNode) {
Category c = (Category) ((NamedNode)value).getUserObject();
value = c.getName(getRaplaLocale().getLocale());
if (editKeys) {
value = "{" + c.getKey() + "} " + value;
}
}
return iconRenderer.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus );
}
});
newButton.setText( getString("new_category") );
newButton.setIcon( getIcon("icon.new"));
newSubButton.setText( getString("new_sub-category") );
newSubButton.setIcon( getIcon("icon.new") );
removeButton.setText( getString("delete") );
removeButton.setIcon( getIcon("icon.delete") );
detailPanel.addChangeListener( listener );
detailPanel.setEditKeys( editKeys );
}
final private TreeFactory getTreeFactory() {
return getService(TreeFactory.class);
}
class Listener implements ActionListener,ChangeListener {
public void actionPerformed(ActionEvent evt) {
try {
if ( evt.getSource() == newButton ) {
createCategory( false );
} else if ( evt.getSource() == newSubButton ) {
createCategory( true );
} else if ( evt.getSource() == removeButton ) {
removeCategory();
} else if ( evt.getSource() == moveUpButton ) {
moveCategory( -1);
} else if ( evt.getSource() == moveDownButton ) {
moveCategory( 1);
} else if (evt.getActionCommand().equals("edit")) {
Category category = (Category) treeEdit.getSelectedValue();
detailPanel.mapFrom( category );
}
} catch (RaplaException ex) {
showException(ex, getComponent());
}
}
public void stateChanged(ChangeEvent e) {
try {
confirmEdits();
} catch (RaplaException ex) {
showException(ex, getComponent());
}
}
}
public JComponent getComponent() {
return panel;
}
public int getSelectedIndex() {
return treeEdit.getSelectedIndex();
}
public void setObjects(List<Category> o) throws RaplaException {
this.rootCategory = o.get(0);
updateModel();
}
public void processCreateNew() throws RaplaException {
if ( createNew )
{
createCategory( false);
}
}
private void createCategory(boolean bCreateSubCategory) throws RaplaException {
confirmEdits();
Category newCategory;
NamedNode parentNode;
TreePath path = treeEdit.getTree().getSelectionPath();
if (path == null) {
parentNode = (NamedNode)model.getRoot();
} else {
NamedNode selectedNode = (NamedNode) path.getLastPathComponent();
if (selectedNode.getParent() == null || bCreateSubCategory)
parentNode = selectedNode;
else
parentNode = (NamedNode)selectedNode.getParent();
}
newCategory = createNewNodeAt( parentNode );
updateModel();
NamedNode newNode = (NamedNode)((NamedNode)model.getRoot()).findNodeFor( newCategory );
TreePath selectionPath = new TreePath( newNode.getPath() );
treeEdit.getTree().setSelectionPath( selectionPath );
detailPanel.name.selectAll();
detailPanel.name.requestFocus();
}
private String createNewKey(Category[] subCategories) {
int max = 1;
for (int i=0;i<subCategories.length;i++) {
String key = subCategories[i].getKey();
if (key.length()>1
&& key.charAt(0) =='c'
&& Character.isDigit(key.charAt(1))
)
{
try {
int value = Integer.valueOf(key.substring(1)).intValue();
if (value >= max)
max = value + 1;
} catch (NumberFormatException ex) {
}
}
}
return "c" + (max);
}
// creates a new Category
private Category createNewNodeAt(NamedNode parentNode) throws RaplaException {
Category newCategory = getModification().newCategory();
Category parent = (Category) parentNode.getUserObject();
newCategory.setKey(createNewKey(parent.getCategories()));
newCategory.getName().setName(getI18n().getLang(), getString("new_category") );
parent.addCategory(newCategory);
getLogger().debug(" new category " + newCategory + " added to " + parent);
return newCategory;
}
private void removeCategory()
{
TreePath[] paths = treeEdit.getTree().getSelectionPaths();
if ( paths == null )
return;
NamedNode[] categoryNodes = new NamedNode[paths.length];
for (int i=0;i<paths.length;i++) {
categoryNodes[i] = (NamedNode) paths[i].getLastPathComponent();
}
removeNodes(categoryNodes);
updateModel();
}
private void moveCategory( int direction )
{
TreePath[] paths = treeEdit.getTree().getSelectionPaths();
if ( paths == null || paths.length == 0)
return;
NamedNode categoryNode = (NamedNode)paths[0].getLastPathComponent();
if ( categoryNode == null)
{
return;
}
Category selectedCategory = (Category)categoryNode.getUserObject();
Category parent = selectedCategory.getParent();
if ( parent == null || selectedCategory.equals( rootCategory))
return;
Category[] childs = parent.getCategories();
for ( int i=0;i<childs.length;i++)
{
parent.removeCategory( childs[i]);
}
if ( direction == -1)
{
Category last = null;
for ( int i=0;i<childs.length;i++)
{
Category current = childs[i];
if ( current.equals( selectedCategory)) {
parent.addCategory( current);
}
if ( last != null && !last.equals( selectedCategory))
{
parent.addCategory(last);
}
last = current;
}
if (last != null && !last.equals( selectedCategory)) {
parent.addCategory(last);
}
}
else
{
boolean insertNow = false;
for ( int i=0;i<childs.length;i++)
{
Category current = childs[i];
if ( !current.equals( selectedCategory)) {
parent.addCategory( current);
} else {
insertNow = true;
continue;
}
if ( insertNow)
{
insertNow = false;
parent.addCategory( selectedCategory);
}
}
if ( insertNow) {
parent.addCategory( selectedCategory);
}
}
updateModel();
}
public void removeNodes(NamedNode[] nodes) {
ArrayList<NamedNode> childList = new ArrayList<NamedNode>();
TreeNode[] path = null;
NamedNode parentNode = null;
for (int i=0;i<nodes.length;i++) {
if (parentNode == null) {
path= nodes[i].getPath();
parentNode = (NamedNode)nodes[i].getParent();
}
// dont't delete the root-node
if (parentNode == null)
continue;
int index = parentNode.getIndexOfUserObject(nodes[i].getUserObject());
if (index >= 0) {
childList.add(nodes[i]);
}
}
if (path != null) {
int size = childList.size();
NamedNode[] childs = new NamedNode[size];
for (int i=0;i<size;i++) {
childs[i] = childList.get(i);
}
for (int i=0;i<size;i++) {
Category subCategory = (Category)childs[i].getUserObject();
subCategory.getParent().removeCategory(subCategory);
getLogger().debug("category removed " + subCategory);
}
}
}
public void mapToObjects() throws RaplaException {
validate( this.rootCategory );
confirmEdits();
}
public List<Category> getObjects() {
return Collections.singletonList(this.rootCategory);
}
private void updateModel() {
model = getTreeFactory().createModel( rootCategory);
RaplaTree.exchangeTreeModel( model , treeEdit.getTree() );
}
public void confirmEdits() throws RaplaException {
if ( getSelectedIndex() < 0 )
return;
Category category = (Category) treeEdit.getSelectedValue();
detailPanel.mapTo ( category );
TreePath path = treeEdit.getTree().getSelectionPath();
if (path != null)
((DefaultTreeModel) model).nodeChanged((TreeNode)path.getLastPathComponent() );
}
private void validate(Category category) throws RaplaException {
checkKey( category.getKey() );
Category[] categories = category.getCategories();
for ( int i=0; i< categories.length;i++) {
validate( categories[i] );
}
}
private void checkKey(String key) throws RaplaException {
if (key.length() ==0)
throw new RaplaException(getString("error.no_key"));
if (!Tools.isKey(key) || key.length()>50)
{
Object[] param = new Object[3];
param[0] = key;
param[1] = "'-', '_'";
param[2] = "'_'";
throw new RaplaException(getI18n().format("error.invalid_key", param));
}
}
public void setEditKeys(boolean editKeys) {
detailPanel.setEditKeys(editKeys);
this.editKeys = editKeys;
}
}
class CategoryDetail extends RaplaGUIComponent
implements
ChangeListener
{
JPanel mainPanel = new JPanel();
Category currentCategory;
JPanel panel = new JPanel();
JLabel nameLabel = new JLabel();
JLabel keyLabel = new JLabel();
JLabel colorLabel = new JLabel();
MultiLanguageField name;
TextField key;
TextField colorTextField;
JPanel colorPanel = new JPanel();
RaplaArrowButton addButton = new RaplaArrowButton('>', 25);
RaplaArrowButton removeButton = new RaplaArrowButton('<', 25);
public CategoryDetail(RaplaContext context)
{
super( context);
name = new MultiLanguageField(context);
key = new TextField(context);
colorTextField = new TextField(context);
double fill = TableLayout.FILL;
double pre = TableLayout.PREFERRED;
panel.setLayout( new TableLayout( new double[][]
{{5, pre, 5, fill }, // Columns
{5, pre ,5, pre, 5, pre, 5}} // Rows
));
panel.add("1,1,l,f", nameLabel);
panel.add("3,1,f,f", name.getComponent() );
panel.add("1,3,l,f", keyLabel);
panel.add("3,3,f,f", key.getComponent() );
panel.add("1,5,l,f", colorLabel);
panel.add("3,5,f,f", colorPanel);
colorPanel.setLayout( new BorderLayout());
colorPanel.add( colorTextField.getComponent(), BorderLayout.CENTER );
nameLabel.setText(getString("name") + ":");
keyLabel.setText(getString("key") + ":");
colorLabel.setText( getString("color") + ":");
name.addChangeListener ( this );
key.addChangeListener ( this );
colorTextField.addChangeListener( this );
// Add everything to the MainPanel
mainPanel.setLayout(new BorderLayout());
mainPanel.add(panel, BorderLayout.NORTH);
}
class CategoryListCellRenderer extends DefaultListCellRenderer {
private static final long serialVersionUID = 1L;
private boolean filterStyle;
public CategoryListCellRenderer(boolean filterStyle) {
this.filterStyle = filterStyle;
}
public CategoryListCellRenderer() {
this(false);
}
public Component getListCellRendererComponent(JList list, Object value,
int index, boolean isSelected, boolean cellHasFocus) {
super.getListCellRendererComponent(list, value, index, isSelected,
cellHasFocus);
if (filterStyle == true)
setFont((getFont().deriveFont(Font.PLAIN)));
if (value != null && value instanceof Category) {
setText(((Category) value).getName(getLocale()));
}
return this;
}
}
public void requestFocus() {
name.requestFocus();
}
public void setEditKeys(boolean editKeys) {
keyLabel.setVisible( editKeys );
key.getComponent().setVisible( editKeys );
colorLabel.setVisible( editKeys );
colorTextField.getComponent().setVisible( editKeys );
}
public JComponent getComponent() {
return mainPanel;
}
public void mapFrom(Category category) {
name.setValue( category.getName());
key.setValue( category.getKey());
String color = category.getAnnotation( CategoryAnnotations.KEY_NAME_COLOR);
if ( color != null)
{
colorTextField.setValue( color );
}
else
{
colorTextField.setValue( null );
}
currentCategory = category;
}
public void mapTo(Category category) throws RaplaException {
category.getName().setTo( name.getValue());
category.setKey( key.getValue());
String colorValue = colorTextField.getValue().toString().trim();
if ( colorValue.length() > 0) {
category.setAnnotation(CategoryAnnotations.KEY_NAME_COLOR, colorValue );
} else {
category.setAnnotation(CategoryAnnotations.KEY_NAME_COLOR, null );
}
}
public void stateChanged(ChangeEvent e) {
fireContentChanged();
}
ArrayList<ChangeListener> listenerList = new ArrayList<ChangeListener>();
public void addChangeListener(ChangeListener listener) {
listenerList.add(listener);
}
public void removeChangeListener(ChangeListener listener) {
listenerList.remove(listener);
}
public ChangeListener[] getChangeListeners() {
return listenerList.toArray(new ChangeListener[]{});
}
protected void fireContentChanged() {
if (listenerList.size() == 0)
return;
ChangeEvent evt = new ChangeEvent(this);
ChangeListener[] listeners = getChangeListeners();
for (int i = 0;i<listeners.length; i++) {
listeners[i].stateChanged(evt);
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit;
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.JTree;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import org.rapla.entities.Category;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.Classification;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.entities.dynamictype.DynamicTypeAnnotations;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.EditField;
import org.rapla.gui.TreeFactory;
import org.rapla.gui.internal.edit.fields.AbstractEditField;
import org.rapla.gui.internal.edit.fields.BooleanField;
import org.rapla.gui.internal.edit.fields.GroupListField;
import org.rapla.gui.internal.edit.fields.TextField;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.RaplaButton;
import org.rapla.gui.toolkit.RaplaTree;
/****************************************************************
* This is the controller-class for the User-Edit-Panel *
****************************************************************/
/*User
1. username, string
2. name,string
3. email,string,
4. isadmin,boolean
*/
class UserEditUI extends AbstractEditUI<User> {
TextField usernameField;
PersonSelectField personSelect;
TextField nameField;
TextField emailField;
AdminBooleanField adminField;
GroupListField groupField;
/**
* @param context
* @throws RaplaException
*/
public UserEditUI(RaplaContext context) throws RaplaException {
super(context);
List<EditField> fields = new ArrayList<EditField>();
usernameField = new TextField(context,getString("username"));
fields.add(usernameField);
personSelect = new PersonSelectField(context);
fields.add(personSelect);
nameField = new TextField(context,getString("name"));
fields.add(nameField);
emailField = new TextField(context,getString("email"));
fields.add(emailField);
adminField = new AdminBooleanField(context,getString("admin"),getUser());
fields.add(adminField);
groupField = new GroupListField(context);
fields.add(groupField);
setFields(fields);
}
class AdminBooleanField extends BooleanField implements ChangeListener {
User user;
public AdminBooleanField(RaplaContext sm, String fieldName, User user) {
super(sm, fieldName);
this.user = user;
}
public void stateChanged(ChangeEvent e) {
}
public void actionPerformed(ActionEvent evt) {
if(evt.getActionCommand().equals(getString("no"))) {
try {
if(!isOneAdmin())
{
showWarning(getString("error.no_admin"), getComponent());
setValue(true);
}
}
catch (RaplaException ex)
{
showException(ex, getComponent());
}
}
return;
}
private Boolean isOneAdmin() throws RaplaException {
User[] userList = getQuery().getUsers();
for (final User user: userList)
{
if(!user.equals(this.user) && user.isAdmin())
{
return true;
}
}
return false;
}
}
class PersonSelectField extends AbstractEditField implements ChangeListener, ActionListener {
User user;
JPanel panel = new JPanel();
JToolBar toolbar = new JToolBar();
RaplaButton newButton = new RaplaButton(RaplaButton.SMALL);
RaplaButton removeButton = new RaplaButton(RaplaButton.SMALL);
/**
* @param sm
* @throws RaplaException
*/
public PersonSelectField(RaplaContext sm) throws RaplaException {
super(sm);
setFieldName( getString("person"));
final Category rootCategory = getQuery().getUserGroupsCategory();
if ( rootCategory == null )
return;
toolbar.add( newButton );
toolbar.add( removeButton );
toolbar.setFloatable( false );
panel.setLayout( new BorderLayout() );
panel.add( toolbar, BorderLayout.NORTH );
newButton.addActionListener( this );
removeButton.addActionListener( this );
removeButton.setText( getString("remove") );
removeButton.setIcon( getIcon( "icon.remove" ) );
newButton.setText( getString("bind_with_person") );
newButton.setIcon( getIcon( "icon.new" ) );
}
private void updateButton() {
final boolean personSet = user != null && user.getPerson() != null;
removeButton.setEnabled( personSet) ;
newButton.setEnabled( !personSet) ;
nameField.getComponent().setEnabled( !personSet);
emailField.getComponent().setEnabled( !personSet);
}
public JComponent getComponent() {
return panel;
}
public String getName()
{
return getString("bind_with_person");
}
public void setUser(User o){
user = o;
updateButton();
}
public void actionPerformed(ActionEvent evt) {
if ( evt.getSource() == newButton)
{
try {
showAddDialog();
} catch (RaplaException ex) {
showException(ex,newButton);
}
}
if ( evt.getSource() == removeButton)
{
try {
user.setPerson( null );
user.setEmail( null );
user.setName(null);
nameField.setValue( user.getName());
emailField.setValue( user.getEmail());
updateButton();
} catch (RaplaException ex) {
showException(ex, getComponent());
}
}
}
public void stateChanged(ChangeEvent evt) {
}
private void showAddDialog() throws RaplaException {
final DialogUI dialog;
RaplaTree treeSelection = new RaplaTree();
treeSelection.setMultiSelect(true);
final TreeFactory treeFactory = getTreeFactory();
treeSelection.getTree().setCellRenderer(treeFactory.createRenderer());
final DynamicType[] personTypes = getQuery().getDynamicTypes(DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON);
List<ClassificationFilter> filters = new ArrayList<ClassificationFilter>();
for (DynamicType personType: personTypes)
{
if ( personType.getAttribute("email") != null)
{
final ClassificationFilter filter = personType.newClassificationFilter();
filters.add( filter);
}
}
final Allocatable[] allocatables = getQuery().getAllocatables(filters.toArray(ClassificationFilter.CLASSIFICATIONFILTER_ARRAY));
List<Allocatable> allocatablesWithEmail = new ArrayList<Allocatable>();
for ( Allocatable a: allocatables)
{
final Classification classification = a.getClassification();
final Attribute attribute = classification.getAttribute("email");
if ( attribute != null)
{
final String email = (String)classification.getValue(attribute);
if (email != null && email.length() > 0)
{
allocatablesWithEmail.add( a );
}
}
}
final Allocatable[] allocatableArray = allocatablesWithEmail.toArray(Allocatable.ALLOCATABLE_ARRAY);
treeSelection.exchangeTreeModel(treeFactory.createClassifiableModel(allocatableArray,true));
treeSelection.setMinimumSize(new java.awt.Dimension(300, 200));
treeSelection.setPreferredSize(new java.awt.Dimension(400, 260));
dialog = DialogUI.create(
getContext()
,getComponent()
,true
,treeSelection
,new String[] { getString("apply"),getString("cancel")});
final JTree tree = treeSelection.getTree();
tree.addMouseListener(new MouseAdapter() {
// End dialog when a leaf is double clicked
public void mousePressed(MouseEvent e) {
TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
if (selPath != null && e.getClickCount() == 2) {
final Object lastPathComponent = selPath.getLastPathComponent();
if (((TreeNode) lastPathComponent).isLeaf() )
dialog.getButton(0).doClick();
}
else if (selPath != null && e.getClickCount() == 1) {
final Object lastPathComponent = selPath.getLastPathComponent();
if (((TreeNode) lastPathComponent).isLeaf() )
dialog.getButton(0).setEnabled(true);
else
dialog.getButton(0).setEnabled(false);
}
}
});
dialog.setTitle(getName());
dialog.start();
if (dialog.getSelectedIndex() == 0) {
Iterator<?> it = treeSelection.getSelectedElements().iterator();
while (it.hasNext()) {
user.setPerson((Allocatable) it.next());
nameField.setValue( user.getName());
emailField.setValue( user.getEmail());
updateButton();
}
}
}
}
final private TreeFactory getTreeFactory() {
return getService(TreeFactory.class);
}
@Override
public void mapToObjects() throws RaplaException {
if (objectList == null)
return;
if (objectList.size() == 1 )
{
User user = objectList.iterator().next();
user.setName(nameField.getValue());
user.setEmail( emailField.getValue());
user.setUsername( usernameField.getValue());
user.setAdmin( adminField.getValue());
// personselect stays in sync
}
groupField.mapTo( objectList);
}
// overwriting of the method by AbstractEditUI
// goal: deactivation of the username-field in case of processing multiple
// objects, to avoid that usernames (identifier) are processed at the same
// time
// => multiple users would have the same username
@Override
protected void mapFromObjects() throws RaplaException {
boolean multiedit = objectList.size() > 1;
if (objectList.size() == 1 )
{
User user = objectList.iterator().next();
nameField.setValue(user.getName());
emailField.setValue(user.getEmail());
usernameField.setValue(user.getUsername( ));
adminField.setValue( user.isAdmin( ));
personSelect.setUser( user);
}
groupField.mapFrom( objectList);
for (EditField field:fields) {
// deactivation of the all fields except group for multiple objects
if (multiedit && !(field instanceof GroupListField ))
{
field.getComponent().setEnabled(false);
field.getComponent().setVisible(false);
}
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JPanel;
import org.rapla.components.util.undo.CommandHistory;
import org.rapla.entities.Category;
import org.rapla.entities.Entity;
import org.rapla.entities.IllegalAnnotationException;
import org.rapla.entities.configuration.Preferences;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.facade.ModificationEvent;
import org.rapla.facade.ModificationListener;
import org.rapla.framework.Disposable;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.EditComponent;
import org.rapla.gui.EditController;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.DisposingTool;
public class EditDialog<T extends Entity> extends RaplaGUIComponent implements ModificationListener,Disposable {
DialogUI dlg;
boolean bSaving = false;
EditComponent<T> ui;
boolean modal;
private Collection<T> originals;
public EditDialog(RaplaContext sm,EditComponent<T> ui,boolean modal){
super( sm);
this.ui = ui;
this.modal = modal;
}
public EditDialog(RaplaContext sm,EditComponent<T> ui) {
this(sm,ui,true);
}
final private EditControllerImpl getPrivateEditDialog() {
return (EditControllerImpl) getService(EditController.class);
}
public int start(Collection<T> editObjects,String title,Component owner)
throws
RaplaException
{
// sets for every object in this array an edit item in the logfile
originals= new ArrayList<T>();
Map<T, T> persistant = getModification().getPersistant( editObjects);
for (T entity : editObjects)
{
getLogger().debug("Editing Object: " + entity);
@SuppressWarnings("unchecked")
Entity<T> mementable = persistant.get( entity);
if ( mementable != null)
{
if ( originals == null)
{
throw new RaplaException("You cannot edit persistant and new entities in one operation");
}
originals.add( mementable.clone() );
}
else
{
if ( originals != null && !originals.isEmpty())
{
throw new RaplaException("You cannot edit persistant and new entities in one operation");
}
originals = null;
}
}
List<T> toEdit = new ArrayList<T>(editObjects);
ui.setObjects(toEdit);
JComponent editComponent = ui.getComponent();
JPanel panel = new JPanel();
panel.setLayout( new BorderLayout());
panel.add( editComponent, BorderLayout.CENTER);
editComponent.setBorder(BorderFactory.createEmptyBorder(3,3,3,3));
dlg = DialogUI.create(getContext(),owner,modal,panel,new String[] {
getString("save")
,getString("cancel")
});
dlg.setAbortAction(new AbortAction());
dlg.getButton(0).setAction(new SaveAction());
dlg.getButton(1).setAction(new AbortAction());
dlg.getButton(0).setIcon(getIcon("icon.save"));
dlg.getButton(1).setIcon(getIcon("icon.cancel"));
dlg.setTitle(getI18n().format("edit.format",title));
getUpdateModule().addModificationListener(this);
dlg.addWindowListener(new DisposingTool(this));
dlg.start();
if (modal)
{
return dlg.getSelectedIndex();
}
else
{
getPrivateEditDialog().addEditDialog( this );
// to avoid java compiler error
EditComponent test = ui;
if ( test instanceof CategoryEditUI)
{
((CategoryEditUI)test).processCreateNew();
}
return -1;
}
}
protected boolean shouldCancelOnModification(ModificationEvent evt) {
List<T> objects = ui.getObjects();
for (T o:objects )
{
// TODO include timestamps in preferencepatches
if ( o instanceof Preferences && ((Preferences)o).getOwner() != null)
{
continue;
}
if (evt.hasChanged(o))
{
return true;
}
}
return false;
}
public void dataChanged(ModificationEvent evt) throws RaplaException {
if (bSaving || dlg == null || !dlg.isVisible() || ui == null)
return;
if (shouldCancelOnModification(evt)) {
getLogger().warn("Object has been changed outside.");
DialogUI warning =
DialogUI.create(getContext()
,ui.getComponent()
,true
,getString("warning")
,getI18n().format("warning.update",ui.getObjects())
);
warning.start();
getPrivateEditDialog().removeEditDialog( this );
dlg.close();
}
}
class SaveAction extends AbstractAction {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent evt) {
try {
ui.mapToObjects();
bSaving = true;
// object which is processed by EditComponent
List<T> saveObjects = ui.getObjects();
Collection<T> entities = new ArrayList<T>();
entities.addAll(saveObjects);
boolean canUndo = true;
for ( T obj: saveObjects)
{
if ( obj instanceof Preferences || obj instanceof DynamicType || obj instanceof Category)
{
canUndo = false;
}
}
if ( canUndo)
{
@SuppressWarnings({ "unchecked", "rawtypes" })
SaveUndo<T> saveCommand = new SaveUndo(getContext(), entities, originals);
CommandHistory commandHistory = getModification().getCommandHistory();
commandHistory.storeAndExecute(saveCommand);
}
else
{
getModification().storeObjects( saveObjects.toArray( new Entity[] {}));
}
getPrivateEditDialog().removeEditDialog(EditDialog.this);
dlg.close();
} catch (IllegalAnnotationException ex) {
showWarning(ex.getMessage(), dlg);
} catch (RaplaException ex) {
showException(ex, dlg);
}
}
}
class AbortAction extends AbstractAction {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent evt) {
getPrivateEditDialog().removeEditDialog( EditDialog.this );
dlg.close();
}
}
public void dispose() {
getUpdateModule().removeModificationListener(this);
}
}
| Java |
package org.rapla.gui.internal.edit;
import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.ListModel;
import javax.swing.UIManager;
import javax.swing.border.EmptyBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.ListDataEvent;
import javax.swing.event.ListDataListener;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import org.rapla.components.calendar.NavButton;
import org.rapla.components.calendar.RaplaArrowButton;
import org.rapla.components.layout.TableLayout;
import org.rapla.components.xmlbundle.I18nBundle;
import org.rapla.gui.toolkit.AWTColorUtil;
import org.rapla.gui.toolkit.RaplaButton;
import org.rapla.gui.toolkit.RaplaWidget;
final public class RaplaListEdit<T> implements
RaplaWidget
{
boolean coloredBackground = false;
int[] oldIndex = new int[0];
JPanel mainPanel = new JPanel();
JPanel statusBar = new JPanel();
JPanel identifierPanel = new JPanel();
JLabel identifier = new JLabel();
JLabel nothingSelectedLabel = new JLabel();
JScrollPane scrollPane;
NavButton prev = new NavButton('^');
NavButton next = new NavButton('v');
RaplaArrowButton moveUpButton = new RaplaArrowButton('^', 25);
RaplaArrowButton moveDownButton = new RaplaArrowButton('v', 25);
Color selectionBackground = UIManager.getColor("List.selectionBackground");
Color background = UIManager.getColor("List.background");
JPanel jointPanel = new JPanel() {
private static final long serialVersionUID = 1L;
int xa[] = new int[4];
int ya[] = new int[4];
public void paint(Graphics g) {
super.paint(g);
Dimension dim = getSize();
int index = list.getSelectedIndex();
Rectangle rect = list.getCellBounds(index,index);
if (rect != null) {
int y = rect.y -scrollPane.getViewport().getViewPosition().y;
int y1= Math.min(dim.height,Math.max(0, y) + scrollPane.getLocation().y);
int y2= Math.min(dim.height,Math.max(0,y + rect.height) + scrollPane.getLocation().y);
xa[0]=0;
ya[0]=y1;
xa[1]=dim.width;
ya[1]=0;
xa[2]=dim.width;
ya[2]=dim.height;
xa[3]=0;
ya[3]=y2;
g.setColor(selectionBackground);
g.fillPolygon(xa,ya,4);
g.setColor(background);
g.drawLine(xa[0],ya[0],xa[1],ya[1]);
g.drawLine(xa[3],ya[3],xa[2],ya[2]);
}
}
};
JPanel content = new JPanel();
JPanel detailContainer = new JPanel();
JPanel editPanel = new JPanel();
JList list = new JList() {
private static final long serialVersionUID = 1L;
@SuppressWarnings("unchecked")
public void setModel(ListModel model) {
super.setModel( model );
model.addListDataListener(new ListDataListener() {
public void contentsChanged(ListDataEvent e) {
modelUpdate();
}
public void intervalAdded(ListDataEvent e) {
}
public void intervalRemoved(ListDataEvent e) {
}
});
}
};
public RaplaButton createNewButton = new RaplaButton();
public RaplaButton removeButton = new RaplaButton();
CardLayout cardLayout = new CardLayout();
private Listener listener = new Listener();
private ActionListener callback;
JPanel toolbar = new JPanel();
public RaplaListEdit(I18nBundle i18n, JComponent detailContent,ActionListener callback)
{
this.callback = callback;
toolbar.setLayout( new BoxLayout( toolbar, BoxLayout.X_AXIS));
toolbar.add(createNewButton);
toolbar.add(removeButton);
toolbar.add(Box.createHorizontalStrut(5));
toolbar.add(moveUpButton);
toolbar.add(moveDownButton);
mainPanel.setLayout(new TableLayout(new double[][] {
{TableLayout.PREFERRED,TableLayout.PREFERRED,TableLayout.FILL}
,{TableLayout.FILL}
}));
jointPanel.setPreferredSize(new Dimension(15,50));
mainPanel.add(content,"0,0");
mainPanel.add(jointPanel,"1,0");
mainPanel.add(editPanel,"2,0");
editPanel.setLayout(cardLayout);
editPanel.add(nothingSelectedLabel, "0");
editPanel.add(detailContainer, "1");
content.setLayout(new BorderLayout());
content.add(toolbar,BorderLayout.NORTH);
scrollPane = new JScrollPane(list
,JScrollPane.VERTICAL_SCROLLBAR_ALWAYS
,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
scrollPane.setPreferredSize(new Dimension(310,80));
content.add(scrollPane, BorderLayout.CENTER);
content.add(statusBar, BorderLayout.SOUTH);
statusBar.setLayout( new FlowLayout(FlowLayout.LEFT));
detailContainer.setLayout(new BorderLayout());
editPanel.setBorder(BorderFactory.createRaisedBevelBorder());
detailContainer.add(identifierPanel,BorderLayout.WEST);
detailContainer.add(detailContent, BorderLayout.CENTER);
//mainPanel.setBorder(new LineBorder(Color.black));
identifierPanel.setLayout(new BorderLayout());
identifierPanel.add(prev,BorderLayout.NORTH);
identifierPanel.add(identifier,BorderLayout.CENTER);
identifierPanel.add(next,BorderLayout.SOUTH);
identifier.setBorder(new EmptyBorder(0,5,0,5));
next.addActionListener(listener);
prev.addActionListener(listener);
removeButton.addActionListener(listener);
createNewButton.addActionListener(listener);
moveUpButton.addActionListener(listener);
moveDownButton.addActionListener(listener);
scrollPane.getViewport().addChangeListener(listener);
// list.setDragEnabled(true);
list.addMouseListener(listener);
list.addListSelectionListener(listener);
modelUpdate();
createNewButton.setText(i18n.getString("new"));
createNewButton.setIcon(i18n.getIcon("icon.new"));
removeButton.setIcon(i18n.getIcon("icon.delete"));
removeButton.setText(i18n.getString("delete"));
nothingSelectedLabel.setHorizontalAlignment(JLabel.CENTER);
nothingSelectedLabel.setText(i18n.getString("nothing_selected"));
}
public JPanel getToolbar()
{
return toolbar;
}
public JComponent getComponent() {
return mainPanel;
}
public JPanel getStatusBar() {
return statusBar;
}
public JList getList() {
return list;
}
public void setListDimension(Dimension d) {
scrollPane.setPreferredSize(d);
}
public void setMoveButtonVisible(boolean visible) {
moveUpButton.setVisible(visible);
moveDownButton.setVisible(visible);
}
public int getSelectedIndex() {
return list.getSelectedIndex();
}
public void select(int index) {
list.setSelectedIndex(index);
if (index >=0) {
list.ensureIndexIsVisible(index);
}
}
public void setColoredBackgroundEnabled(boolean enable) {
coloredBackground = enable;
}
public boolean isColoredBackgroundEnabled() {
return coloredBackground;
}
private void modelUpdate() {
removeButton.setEnabled(list.getMinSelectionIndex() >=0);
moveUpButton.setEnabled(list.getMinSelectionIndex() > 0);
moveDownButton.setEnabled(list.getMinSelectionIndex() >= 0 &&
list.getMaxSelectionIndex() < (list.getModel().getSize() -1) );
jointPanel.repaint();
}
private void editSelectedEntry() {
Object selected = list.getSelectedValue();
if (selected == null) {
cardLayout.first(editPanel);
callback.actionPerformed(new ActionEvent(this
,ActionEvent.ACTION_PERFORMED
,"select"
)
);
return;
} else {
cardLayout.last(editPanel);
int index = getSelectedIndex();
next.setEnabled((index + 1)<list.getModel().getSize());
prev.setEnabled(index>0);
Color color = AWTColorUtil.getAppointmentColor(0);
if ( isColoredBackgroundEnabled() ) {
color = AWTColorUtil.getAppointmentColor(index);
}
identifierPanel.setBackground(color);
identifier.setText(String.valueOf(index + 1));
callback.actionPerformed(new ActionEvent(this
,ActionEvent.ACTION_PERFORMED
,"select"
)
);
callback.actionPerformed(new ActionEvent(this
,ActionEvent.ACTION_PERFORMED
,"edit"
)
);
}
}
private boolean disableListSelection;
public void updateSort(List<Object> selectedValues) {
ListModel model2 = list.getModel();
int[] index = new int[selectedValues.size()];
int j = 0;
for ( int i=0;i<model2.getSize();i++)
{
Object elementAt = model2.getElementAt( i);
if ( selectedValues.contains( elementAt ))
{
index[j++] = i;
}
}
disableListSelection = true;
list.setSelectedIndices( index);
disableListSelection = false;
}
class Listener extends MouseAdapter implements ListSelectionListener,ActionListener,ChangeListener {
public void actionPerformed(ActionEvent evt) {
if (evt.getSource() == next) {
select(Math.min(list.getModel().getSize()-1, getSelectedIndex() + 1));
} else if (evt.getSource() == prev) {
select(Math.max(0, getSelectedIndex()-1));
}
if (evt.getSource() == removeButton) {
callback.actionPerformed(new ActionEvent(RaplaListEdit.this
,ActionEvent.ACTION_PERFORMED
,"remove"
)
);
} else if (evt.getSource() == createNewButton) {
callback.actionPerformed(new ActionEvent(RaplaListEdit.this
,ActionEvent.ACTION_PERFORMED
,"new"
)
);
} else if (evt.getSource() == moveUpButton) {
callback.actionPerformed(new ActionEvent(RaplaListEdit.this
,ActionEvent.ACTION_PERFORMED
,"moveUp"
)
);
} else if (evt.getSource() == moveDownButton) {
callback.actionPerformed(new ActionEvent(RaplaListEdit.this
,ActionEvent.ACTION_PERFORMED
,"moveDown"
)
);
}
}
public void valueChanged(ListSelectionEvent evt) {
if ( disableListSelection )
{
return;
}
//if (evt.getValueIsAdjusting())
//return;
int[] index = list.getSelectedIndices();
if ( index == oldIndex)
{
return;
}
if ( index == null || oldIndex == null || !Arrays.equals( index, oldIndex))
{
oldIndex = index;
editSelectedEntry();
modelUpdate();
}
}
public void stateChanged(ChangeEvent evt) {
if (evt.getSource() == scrollPane.getViewport()) {
jointPanel.repaint();
}
}
}
@SuppressWarnings({ "unchecked", "deprecation" })
public Collection<T> getSelectedValues()
{
return (Collection<T>) Arrays.asList(list.getSelectedValues());
}
@SuppressWarnings("unchecked")
public T getSelectedValue() {
return (T) list.getSelectedValue();
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.BorderLayout;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JSplitPane;
import javax.swing.JToolBar;
import javax.swing.UIManager;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.rapla.entities.Category;
import org.rapla.entities.Entity;
import org.rapla.entities.User;
import org.rapla.entities.domain.Permission;
import org.rapla.facade.CalendarModel;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.facade.ModificationEvent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.framework.TypedComponentRole;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.action.SaveableToggleAction;
import org.rapla.gui.internal.common.InternMenus;
import org.rapla.gui.internal.common.MultiCalendarView;
import org.rapla.gui.toolkit.RaplaButton;
import org.rapla.gui.toolkit.RaplaMenu;
import org.rapla.gui.toolkit.RaplaMenuItem;
import org.rapla.gui.toolkit.RaplaWidget;
import org.rapla.storage.UpdateResult;
final public class CalendarEditor extends RaplaGUIComponent implements RaplaWidget {
public static final TypedComponentRole<Boolean> SHOW_CONFLICTS_CONFIG_ENTRY = new TypedComponentRole<Boolean>("org.rapla.showConflicts");
public static final TypedComponentRole<Boolean> SHOW_SELECTION_CONFIG_ENTRY = new TypedComponentRole<Boolean>("org.rapla.showSelection");
public static final String SHOW_SELECTION_MENU_ENTRY = "show_resource_selection";
public static final String SHOW_CONFLICTS_MENU_ENTRY = "show_conflicts";
RaplaMenuItem ownReservationsMenu;
JSplitPane content = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
final private ResourceSelection resourceSelection;
final private SavedCalendarView savedViews;
final private ConflictSelection conflictsView;
final public MultiCalendarView calendarContainer;
final JToolBar minimized;
final JToolBar templatePanel;
final JPanel left;
boolean listenersDisabled = false;
public CalendarEditor(RaplaContext context, final CalendarSelectionModel model) throws RaplaException {
super(context);
calendarContainer = new MultiCalendarView(getContext(), model, this);
calendarContainer.addValueChangeListener(new ChangeListener()
{
public void stateChanged(ChangeEvent e) {
if ( listenersDisabled)
{
return;
}
try {
resourceSelection.updateMenu();
} catch (RaplaException e1) {
getLogger().error(e1.getMessage(), e1);
}
}
});
resourceSelection = new ResourceSelection(context, calendarContainer, model);
final ChangeListener treeListener = new ChangeListener() {
public void stateChanged(ChangeEvent e) {
if ( listenersDisabled)
{
return;
}
conflictsView.clearSelection();
}
};
final RaplaMenu viewMenu = getService( InternMenus.VIEW_MENU_ROLE);
ownReservationsMenu = new RaplaMenuItem("only_own_reservations");
ownReservationsMenu.setText( getString("only_own_reservations"));
ownReservationsMenu = new RaplaMenuItem("only_own_reservations");
ownReservationsMenu.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
boolean isSelected = model.isOnlyCurrentUserSelected();
// switch selection options
model.setOption( CalendarModel.ONLY_MY_EVENTS, isSelected ? "false":"true");
updateOwnReservationsSelected();
try {
Entity preferences = getQuery().getPreferences();
UpdateResult modificationEvt = new UpdateResult( getUser());
modificationEvt.addOperation( new UpdateResult.Change(preferences, preferences));
resourceSelection.dataChanged(modificationEvt);
calendarContainer.update(modificationEvt);
conflictsView.dataChanged( modificationEvt);
} catch (Exception ex) {
showException(ex, getComponent());
}
}
});
ownReservationsMenu.setText( getString("only_own_reservations"));
ownReservationsMenu.setIcon( getIcon("icon.unchecked"));
updateOwnReservationsSelected();
viewMenu.insertBeforeId( ownReservationsMenu, "show_tips" );
resourceSelection.getTreeSelection().addChangeListener( treeListener);
conflictsView = new ConflictSelection(context, calendarContainer, model);
left = new JPanel(new GridBagLayout());
GridBagConstraints c = new GridBagConstraints();
c.gridheight = 1;
c.gridx = 1;
c.gridy = 1;
c.weightx = 0;
c.weighty = 0;
c.anchor = GridBagConstraints.EAST;
final JButton max = new JButton();
final JButton tree = new JButton();
tree.setEnabled( false );
minimized = new JToolBar(JToolBar.VERTICAL);
minimized.setFloatable( false);
minimized.add( max);
minimized.add( tree);
max.setIcon( UIManager.getDefaults().getIcon("InternalFrame.maximizeIcon"));
tree.setIcon( getIcon("icon.tree"));
JButton min = new RaplaButton(RaplaButton.SMALL);
ActionListener minmaxAction = new ActionListener() {
public void actionPerformed(ActionEvent e) {
savedViews.closeFilter();
int index = viewMenu.getIndexOfEntryWithId(SHOW_SELECTION_MENU_ENTRY);
JMenuItem component = (JMenuItem)viewMenu.getMenuComponent( index);
((SaveableToggleAction)component.getAction()).toggleCheckbox( component);
}
};
min.addActionListener( minmaxAction);
max.addActionListener( minmaxAction);
tree.addActionListener( minmaxAction);
templatePanel = new JToolBar(JToolBar.VERTICAL);
templatePanel.setFloatable( false);
final JButton exitTemplateEdit = new JButton();
//exitTemplateEdit.setIcon(getIcon("icon.close"));
exitTemplateEdit.setText(getString("close-template"));
templatePanel.add( exitTemplateEdit);
exitTemplateEdit.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
getModification().setTemplateName( null );
}
});
Icon icon = UIManager.getDefaults().getIcon("InternalFrame.minimizeIcon");
min.setIcon( icon) ;
//left.add(min, c);
c.fill = GridBagConstraints.HORIZONTAL;
c.weightx = 1;
c.gridy = 1;
JPanel jp = new JPanel();
jp.setLayout( new BorderLayout());
savedViews = new SavedCalendarView(context, calendarContainer, resourceSelection,model);
jp.add( savedViews.getComponent(), BorderLayout.CENTER );
templatePanel.setVisible( false);
jp.add( templatePanel, BorderLayout.WEST );
JToolBar mintb =new JToolBar();
mintb.setFloatable( false);
// mintb.add( min);
min.setAlignmentY( JButton.TOP);
jp.add( min, BorderLayout.EAST);
left.add(jp, c);
c.fill = GridBagConstraints.BOTH;
c.gridy = 2;
c.weightx = 1;
c.weighty = 2.5;
left.add(resourceSelection.getComponent(), c);
c.weighty = 1.0;
c.gridy = 3;
left.add(conflictsView.getComponent(), c);
c.weighty = 0.0;
c.fill = GridBagConstraints.NONE;
c.gridy = 4;
c.anchor = GridBagConstraints.WEST;
left.add(conflictsView.getSummaryComponent(), c);
content.setRightComponent(calendarContainer.getComponent());
updateViews();
}
public void updateOwnReservationsSelected()
{
final CalendarSelectionModel model = resourceSelection.getModel();
boolean isSelected = model.isOnlyCurrentUserSelected();
ownReservationsMenu.setIcon(isSelected ? getIcon("icon.checked") : getIcon("icon.unchecked"));
ownReservationsMenu.setSelected(isSelected);
boolean canSeeEventsFromOthers = canSeeEventsFromOthers();
ownReservationsMenu.setEnabled( canSeeEventsFromOthers);
if ( !canSeeEventsFromOthers && !isSelected)
{
model.setOption(CalendarModel.ONLY_MY_EVENTS, "true");
}
}
private boolean canSeeEventsFromOthers() {
try {
Category category = getQuery().getUserGroupsCategory().getCategory(Permission.GROUP_CAN_READ_EVENTS_FROM_OTHERS);
if (category == null) {
return true;
}
User user = getUser();
return user.isAdmin() || user.belongsTo(category);
} catch (RaplaException ex) {
return false;
}
}
public void dataChanged(ModificationEvent evt) throws RaplaException {
listenersDisabled = true;
try
{
resourceSelection.dataChanged(evt);
calendarContainer.update(evt);
savedViews.update();
conflictsView.dataChanged(evt);
updateViews();
// this is done in calendarContainer update
//updateOwnReservationsSelected();
}
finally
{
listenersDisabled = false;
}
}
private void updateViews() throws RaplaException {
boolean showConflicts = getClientFacade().getPreferences().getEntryAsBoolean( SHOW_CONFLICTS_CONFIG_ENTRY, true);
boolean showSelection = getClientFacade().getPreferences().getEntryAsBoolean( SHOW_SELECTION_CONFIG_ENTRY, true);
conflictsView.getComponent().setVisible( showConflicts);
conflictsView.getSummaryComponent().setVisible( !showConflicts );
boolean templateMode = getModification().getTemplateName() != null;
if ( templateMode)
{
conflictsView.getComponent().setVisible(false);
conflictsView.getSummaryComponent().setVisible( false);
}
// if ( templateMode)
// {
// if ( content.getLeftComponent() != templatePanel)
// {
// content.setLeftComponent( templatePanel);
// content.setDividerSize(0);
// }
// }
// else
// {
if ( showSelection )
{
savedViews.getComponent().setVisible( !templateMode );
templatePanel.setVisible( templateMode);
resourceSelection.getFilterButton().setVisible( !templateMode );
if ( content.getLeftComponent() != left )
{
content.setLeftComponent( left);
content.setDividerSize( 5);
content.setDividerLocation(285);
}
}
else if ( content.getLeftComponent() != minimized)
{
content.setLeftComponent( minimized);
content.setDividerSize(0);
}
// }
}
public void start() {
calendarContainer.getSelectedCalendar().scrollToStart();
}
public JComponent getComponent() {
return content;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.util.Locale;
import javax.swing.JCheckBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import org.rapla.components.layout.TableLayout;
import org.rapla.entities.configuration.Preferences;
import org.rapla.facade.internal.CalendarOptionsImpl;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.OptionPanel;
import org.rapla.gui.RaplaGUIComponent;
public class WarningsOption extends RaplaGUIComponent implements OptionPanel
{
JPanel panel = new JPanel();
Preferences preferences;
JCheckBox showConflictWarningsField = new JCheckBox();
public WarningsOption(RaplaContext sm) {
super( sm);
showConflictWarningsField.setText("");
double pre = TableLayout.PREFERRED;
panel.setLayout( new TableLayout(new double[][] {{pre, 5,pre}, {pre}}));
panel.add( new JLabel(getString("warning.conflict")),"0,0");
panel.add( showConflictWarningsField,"2,0");
}
public JComponent getComponent() {
return panel;
}
public String getName(Locale locale) {
return getString("warnings");
}
public void setPreferences( Preferences preferences) {
this.preferences = preferences;
}
public void show() throws RaplaException {
// get the options
boolean config = preferences.getEntryAsBoolean( CalendarOptionsImpl.SHOW_CONFLICT_WARNING, true);
showConflictWarningsField.setSelected( config);
}
public void commit() {
// Save the options
boolean selected = showConflictWarningsField.isSelected();
preferences.putEntry( CalendarOptionsImpl.SHOW_CONFLICT_WARNING, selected);
}
} | Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.Color;
import org.rapla.components.calendar.DateRenderer;
import org.rapla.components.calendar.WeekendHighlightRenderer;
import org.rapla.entities.domain.Period;
import org.rapla.facade.PeriodModel;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
public class RaplaDateRenderer extends RaplaComponent implements DateRenderer {
protected WeekendHighlightRenderer renderer = new WeekendHighlightRenderer();
protected Color periodColor = new Color(0xc5,0xda,0xdd);
protected PeriodModel periodModel;
public RaplaDateRenderer(RaplaContext sm) {
super(sm);
periodModel = getPeriodModel();
}
public RenderingInfo getRenderingInfo(int dayOfWeek,int day,int month, int year)
{
Period period = periodModel.getPeriodFor(getRaplaLocale().toRaplaDate(year,month,day));
if (period != null)
{
Color backgroundColor = periodColor;
Color foregroundColor = Color.BLACK;
String tooltipText = "<html>" + getString("period") + ":<br>" + period.getName(getI18n().getLocale()) + "</html>";
return new RenderingInfo(backgroundColor, foregroundColor, tooltipText);
}
return renderer.getRenderingInfo(dayOfWeek,day,month,year);
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Enumeration;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.DefaultListModel;
import javax.swing.Icon;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSeparator;
import javax.swing.JTextField;
import javax.swing.KeyStroke;
import javax.swing.MenuElement;
import javax.swing.SwingUtilities;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import org.rapla.client.ClientService;
import org.rapla.client.RaplaClientExtensionPoints;
import org.rapla.components.layout.TableLayout;
import org.rapla.components.util.IOUtil;
import org.rapla.components.util.undo.CommandHistory;
import org.rapla.components.util.undo.CommandHistoryChangedListener;
import org.rapla.entities.configuration.Preferences;
import org.rapla.entities.domain.Reservation;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.facade.ModificationEvent;
import org.rapla.facade.ModificationListener;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.RaplaException;
import org.rapla.framework.TypedComponentRole;
import org.rapla.framework.internal.ConfigTools;
import org.rapla.gui.EditController;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.action.RestartRaplaAction;
import org.rapla.gui.internal.action.RestartServerAction;
import org.rapla.gui.internal.action.SaveableToggleAction;
import org.rapla.gui.internal.action.user.UserAction;
import org.rapla.gui.internal.common.InternMenus;
import org.rapla.gui.internal.edit.DeleteUndo;
import org.rapla.gui.internal.edit.reservation.SortedListModel;
import org.rapla.gui.internal.print.PrintAction;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.HTMLView;
import org.rapla.gui.toolkit.IdentifiableMenuEntry;
import org.rapla.gui.toolkit.RaplaButton;
import org.rapla.gui.toolkit.RaplaFrame;
import org.rapla.gui.toolkit.RaplaMenu;
import org.rapla.gui.toolkit.RaplaMenuItem;
import org.rapla.gui.toolkit.RaplaSeparator;
import org.rapla.gui.toolkit.RaplaWidget;
import org.rapla.plugin.abstractcalendar.RaplaBuilder;
public class RaplaMenuBar extends RaplaGUIComponent
{
final JMenuItem exit;
final JMenuItem redo;
final JMenuItem undo;
JMenuItem templateEdit;
public RaplaMenuBar(RaplaContext context) throws RaplaException {
super(context);
RaplaMenu systemMenu = getService( InternMenus.FILE_MENU_ROLE );
systemMenu.setText( getString("file"));
RaplaMenu editMenu = getService( InternMenus.EDIT_MENU_ROLE );
editMenu.setText( getString("edit"));
RaplaMenu exportMenu = getService( InternMenus.EXPORT_MENU_ROLE );
exportMenu.setText( getString("export"));
RaplaMenu importMenu = getService( InternMenus.IMPORT_MENU_ROLE );
importMenu.setText( getString("import"));
JMenuItem newMenu = getService( InternMenus.NEW_MENU_ROLE );
newMenu.setText( getString("new"));
JMenuItem calendarSettings = getService( InternMenus.CALENDAR_SETTINGS );
calendarSettings.setText( getString("calendar"));
RaplaMenu extraMenu = getService( InternMenus.EXTRA_MENU_ROLE);
extraMenu.setText( getString("help"));
RaplaMenu adminMenu = getService( InternMenus.ADMIN_MENU_ROLE );
adminMenu.setText( getString("admin"));
RaplaMenu viewMenu = getService( InternMenus.VIEW_MENU_ROLE );
viewMenu.setText( getString("view"));
viewMenu.add( new RaplaSeparator("view_save"));
if ( getUser().isAdmin())
{
addPluginExtensions( RaplaClientExtensionPoints.ADMIN_MENU_EXTENSION_POINT, adminMenu);
}
addPluginExtensions( RaplaClientExtensionPoints.IMPORT_MENU_EXTENSION_POINT, importMenu);
addPluginExtensions( RaplaClientExtensionPoints.EXPORT_MENU_EXTENSION_POINT, exportMenu);
addPluginExtensions( RaplaClientExtensionPoints.HELP_MENU_EXTENSION_POINT, extraMenu);
addPluginExtensions( RaplaClientExtensionPoints.VIEW_MENU_EXTENSION_POINT,viewMenu);
addPluginExtensions( RaplaClientExtensionPoints.EDIT_MENU_EXTENSION_POINT, editMenu);
systemMenu.add( newMenu);
systemMenu.add( calendarSettings);
systemMenu.add( new JSeparator());
systemMenu.add( exportMenu );
systemMenu.add( importMenu );
systemMenu.add( adminMenu);
JSeparator printSep = new JSeparator();
printSep.setName(getString("calendar"));
systemMenu.add( printSep);
JMenuItem printMenu = new JMenuItem( getString("print"));
PrintAction printAction = new PrintAction(getContext());
printMenu.setAction( printAction );
printAction.setEnabled( true );
CalendarSelectionModel model = getService(CalendarSelectionModel.class);
printAction.setModel(model);
systemMenu.add( printMenu );
systemMenu.add( new JSeparator());
if ( getService(ClientService.class).canSwitchBack() ) {
JMenuItem switchBack = new JMenuItem();
switchBack.setAction( new UserAction(getContext(),null,null).setSwitchToUser());
adminMenu.add( switchBack );
}
boolean server = getUpdateModule().isClientForServer();
if ( server && isAdmin() ) {
JMenuItem restartServer = new JMenuItem();
restartServer.setAction( new RestartServerAction(getContext()));
adminMenu.add( restartServer );
}
Listener listener = new Listener();
JMenuItem restart = new JMenuItem();
restart.setAction( new RestartRaplaAction(getContext()));
systemMenu.add( restart );
systemMenu.setMnemonic('F');
exit = new JMenuItem(getString("exit"));
exit.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Q, ActionEvent.CTRL_MASK ) );
exit.setMnemonic('x');
exit.addActionListener( listener );
systemMenu.add( exit );
redo = new JMenuItem(getString("redo"));
undo = new JMenuItem(getString("undo"));
undo.setToolTipText(getString("undo"));
undo.setIcon(getIcon("icon.undo"));
redo.addActionListener( listener);
undo.addActionListener( listener);
redo.setToolTipText(getString("redo"));
redo.setIcon(getIcon("icon.redo"));
getModification().getCommandHistory().addCommandHistoryChangedListener(listener);
undo.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Z, ActionEvent.CTRL_MASK ) );
redo.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Y, ActionEvent.CTRL_MASK ) );
undo.setEnabled(false);
redo.setEnabled(false);
editMenu.insertBeforeId( undo,"EDIT_BEGIN");
editMenu.insertBeforeId( redo,"EDIT_BEGIN" );
RaplaMenuItem userOptions = new RaplaMenuItem("userOptions");
editMenu.add( userOptions );
if ( getQuery().canEditTemplats( getUser()))
{
templateEdit = new RaplaMenuItem("template");
updateTemplateText();
templateEdit.addActionListener( listener);
editMenu.add( templateEdit );
}
if ( isModifyPreferencesAllowed() ) {
userOptions.setAction( createOptionAction( getQuery().getPreferences( )));
} else {
userOptions.setVisible( false );
}
{
SaveableToggleAction action = new SaveableToggleAction( context, "show_tips",RaplaBuilder.SHOW_TOOLTIP_CONFIG_ENTRY);
RaplaMenuItem menu = action.createMenuItem();
viewMenu.insertBeforeId( menu, "view_save" );
}
{
SaveableToggleAction action = new SaveableToggleAction( context, CalendarEditor.SHOW_CONFLICTS_MENU_ENTRY,CalendarEditor.SHOW_CONFLICTS_CONFIG_ENTRY);
RaplaMenuItem menu = action.createMenuItem();
viewMenu.insertBeforeId( menu, "view_save" );
}
{
SaveableToggleAction action = new SaveableToggleAction( context, CalendarEditor.SHOW_SELECTION_MENU_ENTRY,CalendarEditor.SHOW_SELECTION_CONFIG_ENTRY);
RaplaMenuItem menu = action.createMenuItem();
viewMenu.insertBeforeId( menu, "view_save" );
}
if ( isAdmin() ) {
RaplaMenuItem adminOptions = new RaplaMenuItem("adminOptions");
adminOptions.setAction( createOptionAction( getQuery().getSystemPreferences()));
adminMenu.add( adminOptions );
}
RaplaMenuItem info = new RaplaMenuItem("info");
info.setAction( createInfoAction( ));
extraMenu.add( info );
// within the help menu we need another point for the license
RaplaMenuItem license = new RaplaMenuItem("license");
// give this menu item an action to perform on click
license.setAction(createLicenseAction());
// add the license dialog below the info entry
extraMenu.add(license);
adminMenu.setEnabled( adminMenu.getMenuComponentCount() != 0 );
exportMenu.setEnabled( exportMenu.getMenuComponentCount() != 0);
importMenu.setEnabled( importMenu.getMenuComponentCount() != 0);
getUpdateModule().addModificationListener( listener);
}
protected void updateTemplateText() {
if ( templateEdit == null)
{
return;
}
String editString = getString("edit-templates");
String exitString = getString("close-template");
templateEdit.setText(isTemplateEdit() ? exitString : editString);
}
protected boolean isTemplateEdit() {
return getModification().getTemplateName() != null;
}
class Listener implements ActionListener, CommandHistoryChangedListener, ModificationListener
{
public void historyChanged()
{
CommandHistory history = getModification().getCommandHistory();
redo.setEnabled(history.canRedo());
undo.setEnabled(history.canUndo());
redo.setText(getString("redo") + ": " + history.getRedoText());
undo.setText(getString("undo") + ": " + history.getUndoText());
}
public void actionPerformed(ActionEvent e) {
Object source = e.getSource();
if ( source == exit)
{
RaplaFrame mainComponent = (RaplaFrame)getMainComponent();
mainComponent.close();
}
else if ( source == templateEdit)
{
if ( isTemplateEdit())
{
getModification().setTemplateName( null );
}
else
{
templateEdit();
}
}
else
{
CommandHistory commandHistory = getModification().getCommandHistory();
try {
if ( source == redo)
{
commandHistory.redo();
}
if ( source == undo)
{
commandHistory.undo();
}
} catch (Exception ex) {
showException(ex, getMainComponent());
}
}
}
public void dataChanged(ModificationEvent evt) throws RaplaException {
updateTemplateText();
}
}
private void addPluginExtensions(
TypedComponentRole<IdentifiableMenuEntry> extensionPoint,
RaplaMenu menu) throws RaplaContextException
{
Collection<IdentifiableMenuEntry> points = getContainer().lookupServicesFor( extensionPoint);
for (IdentifiableMenuEntry menuItem: points)
{
MenuElement menuElement = menuItem.getMenuElement();
menu.add( menuElement.getComponent());
}
}
private Action createOptionAction( final Preferences preferences) {
AbstractAction action = new AbstractAction() {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent arg0) {
try {
EditController editContrl = getService(EditController.class);
editContrl.edit( preferences, getMainComponent());
} catch (RaplaException ex) {
showException( ex, getMainComponent());
}
}
};
action.putValue( Action.SMALL_ICON, getIcon("icon.options") );
action.putValue( Action.NAME, getString("options"));
return action;
}
private Action createInfoAction( ) {
final String name = getString("info");
final Icon icon = getIcon("icon.info_small");
AbstractAction action = new AbstractAction() {
private static final long serialVersionUID = 1L;
public void actionPerformed( ActionEvent e )
{
try {
HTMLView infoText = new HTMLView();
infoText.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
String javaversion;
try {
javaversion = System.getProperty("java.version");
} catch (SecurityException ex) {
javaversion = "-";
getLogger().warn("Permission to system properties denied!");
}
boolean isSigned = IOUtil.isSigned();
String signed = getString( isSigned ? "yes": "no");
String mainText = getI18n().format("info.text",signed,javaversion);
StringBuffer completeText = new StringBuffer();
completeText.append( mainText);
URL librariesURL = null;
try {
Enumeration<URL> resources = ConfigTools.class.getClassLoader().getResources("META-INF/readme.txt");
if ( resources.hasMoreElements())
{
librariesURL = resources.nextElement();
}
} catch (IOException e1) {
}
if ( librariesURL != null)
{
completeText.append("<pre>\n\n\n");
BufferedReader bufferedReader = null;
try
{
bufferedReader = new BufferedReader( new InputStreamReader( librariesURL.openStream()));
while ( true)
{
String line = bufferedReader.readLine();
if ( line == null)
{
break;
}
completeText.append(line);
completeText.append("\n");
}
}
catch (IOException ex)
{
try {
if ( bufferedReader != null)
{
bufferedReader.close();
}
} catch (IOException e1) {
}
}
completeText.append("</pre>");
}
String body = completeText.toString();
infoText.setBody(body);
final JScrollPane content = new JScrollPane(infoText);
DialogUI dialog = DialogUI.create( getContext(),getMainComponent(),false, content, new String[] {getString("ok")});
dialog.setTitle( name);
dialog.setSize( 780, 580);
dialog.startNoPack();
SwingUtilities.invokeLater( new Runnable()
{
public void run() {
content.getViewport().setViewPosition( new Point(0,0));
}
});
} catch (RaplaException ex) {
showException( ex, getMainComponent());
}
}
};
action.putValue( Action.SMALL_ICON, icon );
action.putValue( Action.NAME, name);
return action;
}
/**
* the action to perform when someone clicks on the license entry in the
* help section of the menu bar
*
* this method is a modified version of the existing method createInfoAction()
*/
private Action createLicenseAction()
{
final String name = getString("licensedialog.title");
final Icon icon = getIcon("icon.info_small");
// overwrite the cass AbstractAction to design our own
AbstractAction action = new AbstractAction()
{
private static final long serialVersionUID = 1L;
// overwrite the actionPerformed method that is called on click
public void actionPerformed(ActionEvent e)
{
try
{
// we need a new instance of HTMLView to visualize the short
// version of the license text including the two links
HTMLView licenseText = new HTMLView();
// giving the gui element some borders
licenseText.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
// we look up the text was originally meant for the welcome field
// and put it into a new instance of RaplaWidget
RaplaWidget welcomeField = getService(ClientService.WELCOME_FIELD);
// the following creates the dialog that pops up, when we click
// on the license entry within the help section of the menu bar
// we call the create Method of the DialogUI class and give it all necessary things
DialogUI dialog = DialogUI.create(getContext(), getMainComponent(), true, new JScrollPane(welcomeField.getComponent()), new String[] { getString("ok") });
// setting the dialog's title
dialog.setTitle(name);
// and the size of the popup window
dialog.setSize(550, 250);
// but I honestly have no clue what this startNoPack() does
dialog.startNoPack();
}
catch (RaplaException ex)
{
showException(ex, getMainComponent());
}
}
};
action.putValue(Action.SMALL_ICON, icon);
action.putValue(Action.NAME, name);
return action;
}
private void templateEdit() {
final Component parentComponent = getMainComponent();
try {
JPanel panel = new JPanel();
final JTextField textField = new JTextField(20);
addCopyPaste( textField);
panel.setPreferredSize( new Dimension(600,300));
panel.setLayout(new TableLayout( new double[][] {{TableLayout.PREFERRED,5,TableLayout.FILL, 5,TableLayout.PREFERRED},{TableLayout.PREFERRED,5,TableLayout.FILL, TableLayout.PREFERRED}}));
panel.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
panel.add(new JLabel("Templatename:"), "0,0");
panel.add(textField, "2,0");
addCopyPaste( textField);
final DefaultListModel model = new DefaultListModel();
@SuppressWarnings("unchecked")
final JList list = new JList(new SortedListModel(model));
Collection<String> templateNames= getQuery().getTemplateNames();
fillModel( model, templateNames);
final RaplaButton deleteButton = new RaplaButton(RaplaButton.SMALL);
deleteButton.setIcon(getIcon("icon.delete"));
panel.add( new JScrollPane(list), "0,2,2,1");
panel.add( deleteButton, "4,2,l,t");
//int selectedIndex = selectionBox.getSelectedIndex();
Object selectedItem = null;
list.setSelectedValue( selectedItem,true);
String templateName = getModification().getTemplateName();
if ( templateName != null)
{
textField.setText( templateName);
}
list.addListSelectionListener( new ListSelectionListener() {
public void valueChanged( ListSelectionEvent e )
{
String template = (String) list.getSelectedValue();
if ( template != null)
{
textField.setText( template );
}
deleteButton.setEnabled( template != null);
}
});
ActionListener actionListener = new ActionListener() {
public void actionPerformed(ActionEvent e) {
Object source = e.getSource();
if ( source == deleteButton)
{
String template = (String) list.getSelectedValue();
if ( template != null)
{
try {
Collection<Reservation> reservations = getQuery().getTemplateReservations(template);
DeleteUndo<Reservation> cmd = new DeleteUndo<Reservation>(getContext(), reservations);
getModification().getCommandHistory().storeAndExecute( cmd);
Collection<String> templateNames= getQuery().getTemplateNames();
fillModel( model, templateNames);
} catch (Exception ex) {
showException( ex, getMainComponent());
}
}
}
}
};
deleteButton.addActionListener( actionListener);
Collection<String> options = new ArrayList<String>();
options.add( getString("apply") );
options.add(getString("cancel"));
final DialogUI dlg = DialogUI.create(
getContext(),
parentComponent,true,panel,
options.toArray(new String[] {}));
dlg.setTitle(getString("edit-templates"));
dlg.getButton(options.size() - 1).setIcon(getIcon("icon.cancel"));
final AbstractAction action = new AbstractAction() {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent e) {
String template = textField.getText();
if ( template == null)
{
template = "";
}
template = template.trim();
if ( template.length() > 0)
{
String selectedTemplate = null;
Enumeration elements = model.elements();
while ( elements.hasMoreElements())
{
String test = (String)elements.nextElement();
if ( test.equals( template))
{
selectedTemplate = test;
break;
}
}
if (selectedTemplate == null)
{
selectedTemplate = template;
}
Date start = null;
if ( selectedTemplate != null)
{
try
{
Collection<Reservation> reservations = getQuery().getTemplateReservations(selectedTemplate);
for ( Reservation r:reservations)
{
Date firstDate = r.getFirstDate();
if ( start == null || firstDate.before(start ))
{
start = firstDate;
}
}
if ( start != null)
{
getService(CalendarSelectionModel.class).setSelectedDate( start);
}
}
catch (RaplaException ex)
{
showException( ex, getMainComponent());
}
}
getModification().setTemplateName( selectedTemplate);
}
else
{
getModification().setTemplateName( null);
}
dlg.close();
}
};
list.addMouseListener( new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if ( e.getClickCount() >=2)
{
action.actionPerformed( new ActionEvent( list, ActionEvent.ACTION_PERFORMED, "save"));
}
}
});
dlg.getButton(0).setAction( action);
dlg.getButton(0).setIcon(getIcon("icon.confirm"));
dlg.start();
updateTemplateText();
} catch (RaplaException ex) {
showException( ex, parentComponent);
}
}
@SuppressWarnings("unchecked")
private void fillModel(DefaultListModel model,Collection<String> templateNames) {
model.removeAllElements();
for ( String template:templateNames)
{
model.addElement( template);
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import javax.swing.AbstractAction;
import javax.swing.BoxLayout;
import javax.swing.JPanel;
import javax.swing.JTextField;
import org.rapla.client.RaplaClientExtensionPoints;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.framework.StartupEnvironment;
import org.rapla.gui.PublishExtension;
import org.rapla.gui.PublishExtensionFactory;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.toolkit.DialogUI;
/**
*/
public class PublishDialog extends RaplaGUIComponent
{
Collection<PublishExtensionFactory> extensionFactories;
PublishExtension addressCreator= null;
public PublishDialog(RaplaContext sm) throws RaplaException
{
super(sm);
if ( !isModifyPreferencesAllowed() ) {
extensionFactories = Collections.emptyList();
}
else
{
extensionFactories = getContainer().lookupServicesFor(RaplaClientExtensionPoints.PUBLISH_EXTENSION_OPTION);
}
}
public boolean hasPublishActions()
{
return extensionFactories.size() > 0;
}
String getAddress(String filename, String generator) {
try
{
StartupEnvironment env = getService( StartupEnvironment.class );
URL codeBase = env.getDownloadURL();
String pageParameters = "page="+generator+"&user=" + getUser().getUsername();
if ( filename != null)
{
pageParameters = pageParameters + "&file=" + URLEncoder.encode( filename, "UTF-8" );
}
final String urlExtension = pageParameters;
return new URL( codeBase,"rapla?" + urlExtension).toExternalForm();
}
catch (Exception ex)
{
return "Not in webstart mode. Exportname is " + filename ;
}
}
public void export(final CalendarSelectionModel model,final Component parentComponent,final String filename) throws RaplaException
{
JPanel panel = new JPanel();
panel.setPreferredSize( new Dimension(600,300));
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
final Collection<PublishExtension> extensions = new ArrayList<PublishExtension>();
addressCreator = null;
for ( PublishExtensionFactory entry:extensionFactories)
{
PublishExtensionFactory extensionFactory = entry;
PublishExtension extension = extensionFactory.creatExtension(model, new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt)
{
updateAddress(filename, extensions);
}
});
JTextField urlField = extension.getURLField();
String generator = extension.getGenerator();
if ( urlField != null)
{
String address = getAddress(filename, generator);
urlField.setText(address);
}
if ( extension.hasAddressCreationStrategy())
{
if ( addressCreator != null)
{
getLogger().error("Only one address creator can be used. " + addressCreator.toString() + " will be ignored.");
}
addressCreator = extension;
}
extensions.add( extension);
JPanel extPanel = extension.getPanel();
if ( extPanel != null)
{
panel.add( extPanel);
}
}
updateAddress(filename, extensions);
final DialogUI dlg = DialogUI.create(
getContext(),
parentComponent,false,panel,
new String[] {
getString("save")
,getString("cancel")
});
dlg.setTitle(getString("publish"));
dlg.getButton(0).setIcon(getIcon("icon.save"));
dlg.getButton(1).setIcon(getIcon("icon.cancel"));
dlg.getButton(0).setAction( new AbstractAction() {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent e) {
dlg.close();
try
{
for (PublishExtension extension :extensions)
{
extension.mapOptionTo();
}
model.save( filename);
}
catch (RaplaException ex)
{
showException( ex, parentComponent);
}
}
});
dlg.start();
}
protected void updateAddress(final String filename,
final Collection<PublishExtension> extensions) {
for ( PublishExtension entry:extensions)
{
PublishExtension extension = entry;
JTextField urlField = extension.getURLField();
if ( urlField != null)
{
String generator = extension.getGenerator();
String address;
if ( addressCreator != null )
{
address = addressCreator.getAddress(filename, generator);
}
else
{
address = getAddress(filename, generator);
}
urlField.setText(address);
}
}
}
} | Java |
package org.rapla.gui.internal;
import java.awt.Component;
import java.awt.Dialog;
import java.awt.Frame;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JComponent;
import javax.swing.JWindow;
import javax.swing.event.ChangeListener;
import org.rapla.components.calendar.RaplaArrowButton;
import org.rapla.facade.ClassifiableFilter;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.edit.ClassifiableFilterEdit;
import org.rapla.gui.toolkit.DialogUI;
public class FilterEditButton extends RaplaGUIComponent
{
protected RaplaArrowButton filterButton;
JWindow popup;
ClassifiableFilterEdit ui;
public FilterEditButton(final RaplaContext context,final ClassifiableFilter filter, final ChangeListener listener, final boolean isResourceSelection)
{
super(context);
filterButton = new RaplaArrowButton('v');
filterButton.setText(getString("filter"));
filterButton.setSize(80,18);
filterButton.addActionListener( new ActionListener()
{
public void actionPerformed(ActionEvent e) {
if ( popup != null)
{
popup.setVisible(false);
popup= null;
filterButton.setChar('v');
return;
}
try {
if ( ui != null && listener != null)
{
ui.removeChangeListener( listener);
}
ui = new ClassifiableFilterEdit( context, isResourceSelection);
if ( listener != null)
{
ui.addChangeListener(listener);
}
ui.setFilter( filter);
final Point locationOnScreen = filterButton.getLocationOnScreen();
final int y = locationOnScreen.y + 18;
final int x = locationOnScreen.x;
if ( popup == null)
{
Component ownerWindow = DialogUI.getOwnerWindow(filterButton);
if ( ownerWindow instanceof Frame)
{
popup = new JWindow((Frame)ownerWindow);
}
else if ( ownerWindow instanceof Dialog)
{
popup = new JWindow((Dialog)ownerWindow);
}
}
JComponent content = ui.getComponent();
popup.setContentPane(content );
popup.setSize( content.getPreferredSize());
popup.setLocation( x, y);
//.getSharedInstance().getPopup( filterButton, ui.getComponent(), x, y);
popup.setVisible(true);
filterButton.setChar('^');
} catch (Exception ex) {
showException(ex, getMainComponent());
}
}
});
}
public ClassifiableFilterEdit getFilterUI()
{
return ui;
}
public RaplaArrowButton getButton()
{
return filterButton;
}
} | Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.action;
import java.awt.Component;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Appointment;
import org.rapla.entities.domain.AppointmentBlock;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaAction;
import org.rapla.gui.ReservationController;
import org.rapla.gui.ReservationEdit;
public class AppointmentAction extends RaplaAction {
public final static int DELETE = 1;
public final static int COPY = 2;
public final static int PASTE = 3;
public final static int CUT = 4;
public final static int EDIT = 6;
public final static int VIEW = 7;
public final static int CHANGE_ALLOCATABLE = 8;
public final static int ADD_TO_RESERVATION = 9;
public final static int PASTE_AS_NEW = 10;
public final static int DELETE_SELECTION = 11;
private boolean keepTime = false;
Component parent;
Point point;
int type;
AppointmentBlock appointmentBlock;
ReservationEdit reservationEdit;
// ReservationWizard wizard;
private Collection<Allocatable> contextAllocatables;
public AppointmentAction(RaplaContext context,Component parent,Point point)
{
super( context);
this.parent = parent;
this.point = point;
}
public AppointmentAction setAddTo(ReservationEdit reservationEdit)
{
this.reservationEdit = reservationEdit;
this.type = ADD_TO_RESERVATION;
String name2 = getName(reservationEdit.getReservation());
String value = name2.trim().length() > 0 ? "'" + name2 + "'" : getString("new_reservation");
putValue(NAME, value);
putValue(SMALL_ICON, getIcon("icon.new"));
boolean canAllocate = canAllocate();
setEnabled( canAllocate);
return this;
}
public AppointmentAction setCopy(AppointmentBlock appointmentBlock, Collection<Allocatable> contextAllocatables) {
this.appointmentBlock = appointmentBlock;
this.type = COPY;
this.contextAllocatables = contextAllocatables;
putValue(NAME, getString("copy"));
putValue(SMALL_ICON, getIcon("icon.copy"));
setEnabled(canCreateReservation());
return this;
}
public AppointmentAction setPaste( boolean keepTime) {
this.type = PASTE;
this.keepTime = keepTime;
putValue(NAME, getString("paste_into_existing_event"));
putValue(SMALL_ICON, getIcon("icon.paste"));
setEnabled(isAppointmentOnClipboard() && canCreateReservation());
return this;
}
public AppointmentAction setPasteAsNew( boolean keepTime) {
this.keepTime = keepTime;
this.type = PASTE_AS_NEW;
putValue(NAME, getString("paste_as") + " " + getString( "new_reservation" ) );
putValue(SMALL_ICON, getIcon("icon.paste_new"));
setEnabled(isAppointmentOnClipboard() && canCreateReservation());
return this;
}
/**
* Context menu entry to delete an appointment.
*/
public AppointmentAction setDelete(AppointmentBlock appointmentBlock){
this.appointmentBlock = appointmentBlock;
Appointment appointment = appointmentBlock.getAppointment();
this.type = DELETE;
putValue(NAME, getI18n().format("delete.format", getString("appointment")));
putValue(SMALL_ICON, getIcon("icon.delete"));
setEnabled(canModify(appointment.getReservation()));
return this;
}
public AppointmentAction setDeleteSelection(Collection<AppointmentBlock> selection) {
this.type = DELETE_SELECTION;
putValue(NAME, getString("delete_selection"));
putValue(SMALL_ICON, getIcon("icon.delete"));
changeSelection( selection );
return this;
}
Collection<AppointmentBlock> blockList;
private void changeSelection(Collection<AppointmentBlock> blockList) {
this.blockList = blockList;
if (type == DELETE_SELECTION) {
boolean enabled = true;
if (blockList != null && blockList.size() > 0 ) {
Iterator<AppointmentBlock> it = blockList.iterator();
while (it.hasNext()) {
if (!canModify(it.next().getAppointment().getReservation())){
enabled = false;
break;
}
}
} else {
enabled = false;
}
setEnabled(enabled);
}
}
public AppointmentAction setView(AppointmentBlock appointmentBlock) {
this.appointmentBlock = appointmentBlock;
Appointment appointment = appointmentBlock.getAppointment();
this.type = VIEW;
putValue(NAME, getString("view"));
putValue(SMALL_ICON, getIcon("icon.help"));
try
{
User user = getUser();
boolean canRead = canRead(appointment, user);
setEnabled( canRead);
}
catch (RaplaException ex)
{
getLogger().error( "Can't get user",ex);
}
return this;
}
public AppointmentAction setEdit(AppointmentBlock appointmentBlock) {
this.appointmentBlock = appointmentBlock;
this.type = EDIT;
putValue(SMALL_ICON, getIcon("icon.edit"));
Appointment appointment = appointmentBlock.getAppointment();
boolean canExchangeAllocatables = getQuery().canExchangeAllocatables(appointment.getReservation());
boolean canModify = canModify(appointment.getReservation());
String text = !canModify && canExchangeAllocatables ? getString("exchange_allocatables") : getString("edit");
putValue(NAME, text);
setEnabled(canModify || canExchangeAllocatables );
return this;
}
public void actionPerformed(ActionEvent evt) {
try {
switch (type) {
case DELETE: delete();break;
case COPY: copy();break;
case PASTE: paste(false);break;
case PASTE_AS_NEW: paste( true);break;
// case NEW: newReservation();break;
case ADD_TO_RESERVATION: addToReservation();break;
case EDIT: edit();break;
case VIEW: view();break;
case DELETE_SELECTION: deleteSelection();break;
}
} catch (RaplaException ex) {
showException(ex,parent);
} // end of try-catch
}
private void deleteSelection() throws RaplaException {
if ( this.blockList == null){
return;
}
getReservationController().deleteBlocks(blockList,parent,point);
}
public void view() throws RaplaException {
Appointment appointment = appointmentBlock.getAppointment();
getInfoFactory().showInfoDialog(appointment.getReservation(),parent,point);
}
public void edit() throws RaplaException {
getReservationController().edit( appointmentBlock);
}
private void delete() throws RaplaException {
getReservationController().deleteAppointment(appointmentBlock,parent,point);
}
private void copy() throws RaplaException
{
getReservationController().copyAppointment(appointmentBlock,parent,point, contextAllocatables);
}
private void paste(boolean asNewReservation) throws RaplaException {
ReservationController reservationController = getReservationController();
CalendarSelectionModel model = getService( CalendarSelectionModel.class);
Date start = getStartDate(model);
reservationController.pasteAppointment( start
,parent
,point
,asNewReservation, keepTime);
}
private void addToReservation() throws RaplaException
{
CalendarSelectionModel model = getService( CalendarSelectionModel.class);
Date start = getStartDate(model);
Date end = getEndDate(model, start);
reservationEdit.addAppointment(start,end);
}
public boolean isAppointmentOnClipboard() {
return (getReservationController().isAppointmentOnClipboard());
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.action.user;
import java.awt.Component;
import java.awt.event.ActionEvent;
import javax.swing.AbstractAction;
import org.rapla.components.util.Tools;
import org.rapla.entities.User;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaAction;
import org.rapla.gui.toolkit.DialogUI;
public class PasswordChangeAction extends RaplaAction {
Object object;
Component parent;
public PasswordChangeAction(RaplaContext context,Component parent) {
super( context);
this.parent = parent;
putValue(NAME, getI18n().format("change.format",getString("password")));
}
public void changeObject(Object object) {
this.object = object;
update();
}
private void update() {
User user = null;
try {
user = getUser();
setEnabled(object != null && (isAdmin() || user.equals(object)));
} catch (RaplaException ex) {
setEnabled(false);
return;
}
}
public void actionPerformed(ActionEvent evt) {
try {
if (object == null)
return;
changePassword((User) object, !getUser().isAdmin());
} catch (RaplaException ex) {
showException(ex, this.parent);
}
}
public void changePassword(User user,boolean showOld) throws RaplaException{
new PasswordChangeActionA(user,showOld).start();
}
class PasswordChangeActionA extends AbstractAction {
private static final long serialVersionUID = 1L;
PasswordChangeUI ui;
DialogUI dlg;
User user;
boolean showOld;
PasswordChangeActionA(User user,boolean showOld) {
this.user = user;
this.showOld = showOld;
putValue(NAME, getString("change"));
}
public void start() throws RaplaException
{
ui = new PasswordChangeUI(getContext(),showOld);
dlg = DialogUI.create(getContext(),parent,true,ui.getComponent(),new String[] {getString("change"),getString("cancel")});
dlg.setDefault(0);
dlg.setTitle(getI18n().format("change.format",getString("password")));
dlg.getButton(0).setAction(this);
dlg.getButton(1).setIcon(getIcon("icon.cancel"));
dlg.start();
}
public void actionPerformed(ActionEvent evt) {
try {
char[] oldPassword = showOld ? ui.getOldPassword() : new char[0];
char[] p1= ui.getNewPassword();
char[] p2= ui.getPasswordVerification();
if (!Tools.match(p1,p2))
throw new RaplaException(getString("error.passwords_dont_match"));
getUserModule().changePassword(user , oldPassword, p1);
dlg.close();
} catch (RaplaException ex) {
showException(ex,dlg);
}
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.action.user;
import java.awt.Component;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.List;
import org.rapla.client.ClientService;
import org.rapla.entities.User;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.EditComponent;
import org.rapla.gui.RaplaAction;
import org.rapla.gui.internal.edit.EditDialog;
public class UserAction extends RaplaAction {
Object object;
Component parent;
public final int NEW = 1;
public final int SWITCH_TO_USER = 3;
int type = NEW;
Point point;
public UserAction(RaplaContext sm,Component parent,Point point) {
super( sm);
this.parent = parent;
this.point = point;
}
public UserAction setNew() {
type = NEW;
putValue(NAME, getString("user"));
putValue(SMALL_ICON, getIcon("icon.new"));
update();
return this;
}
public UserAction setSwitchToUser() {
type = SWITCH_TO_USER;
ClientService service = getService( ClientService.class);
if (service.canSwitchBack()) {
putValue(NAME, getString("switch_back"));
} else {
putValue(NAME, getString("switch_to"));
}
return this;
}
public void changeObject(Object object) {
this.object = object;
update();
}
private void update() {
User user = null;
try {
user = getUser();
if (type == NEW) {
setEnabled(isAdmin());
} else if (type == SWITCH_TO_USER) {
ClientService service = getService( ClientService.class);
setEnabled(service.canSwitchBack() ||
(object != null && isAdmin() && !user.equals(object )));
}
} catch (RaplaException ex) {
setEnabled(false);
return;
}
}
public void actionPerformed(ActionEvent evt) {
try {
if (type == SWITCH_TO_USER) {
ClientService service = getService( ClientService.class);
if (service.canSwitchBack()) {
service.switchTo(null);
//putValue(NAME, getString("switch_to"));
} else if ( object != null ){
service.switchTo((User) object);
// putValue(NAME, getString("switch_back"));
}
} else if (type == NEW) {
User newUser = getModification().newUser();
EditComponent<User> ui = getEditController().createUI( newUser);
EditDialog<User> gui = new EditDialog<User>(getContext(),ui);
List<User> singletonList = new ArrayList<User>();
singletonList.add(newUser);
if (gui.start( singletonList ,getString("user"), parent) == 0
&& getUserModule().canChangePassword() )
changePassword(newUser,false);
object = newUser;
}
} catch (RaplaException ex) {
showException(ex, this.parent);
}
}
public void changePassword(User user,boolean showOld) throws RaplaException{
new PasswordChangeAction(getContext(),parent).changePassword( user, showOld);
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.action.user;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.BoxLayout;
import javax.swing.JCheckBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.toolkit.RaplaWidget;
public class PasswordChangeUI extends RaplaGUIComponent
implements
RaplaWidget
{
JPanel superPanel = new JPanel();
JPanel panel = new JPanel();
JPanel panel2 = new JPanel();
GridLayout gridLayout1 = new GridLayout();
// The Controller for this Dialog
JLabel label1 = new JLabel();
JLabel label2 = new JLabel();
JLabel label3 = new JLabel();
JPasswordField tf1 = new JPasswordField(10);
JPasswordField tf2 = new JPasswordField(10);
JPasswordField tf3 = new JPasswordField(10);
public PasswordChangeUI(RaplaContext sm) {
this(sm,true);
}
public PasswordChangeUI(RaplaContext sm,boolean askForOldPassword) {
super( sm);
superPanel.setLayout(new BoxLayout(superPanel, BoxLayout.Y_AXIS));
panel2.add(new JLabel(getString("password_change_info")));
panel.setLayout(gridLayout1);
gridLayout1.setRows(askForOldPassword ? 4 : 3);
gridLayout1.setColumns(2);
gridLayout1.setHgap(10);
gridLayout1.setVgap(10);
if (askForOldPassword) {
panel.add(label1);
panel.add(tf1);
}
panel.add(label2);
panel.add(tf2);
panel.add(label3);
panel.add(tf3);
label1.setText(getString("old_password") + ":");
label2.setText(getString("new_password") + ":");
label3.setText(getString("password_verification") + ":");
final JCheckBox showPassword = new JCheckBox(getString("show_password"));
panel.add( showPassword);
showPassword.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
boolean show = showPassword.isSelected();
tf1.setEchoChar( show ? ((char) 0): '*');
tf2.setEchoChar( show ? ((char) 0): '*');
tf3.setEchoChar( show ? ((char) 0): '*');
}
});
superPanel.add(panel);
superPanel.add(panel2);
}
public JComponent getComponent() {
return superPanel;
}
public char[] getOldPassword() {
return tf1.getPassword();
}
public char[] getNewPassword() {
return tf2.getPassword();
}
public char[] getPasswordVerification() {
return tf3.getPassword();
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.action;
import java.awt.event.ActionEvent;
import org.rapla.client.ClientService;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.RaplaAction;
public class RestartRaplaAction extends RaplaAction{
public RestartRaplaAction(RaplaContext sm)
{
super(sm);
boolean logoutAvailable = getService(ClientService.class).isLogoutAvailable();
String string = getString("restart_client");
if (logoutAvailable)
{
string = getString("logout") +" / " + string;
}
putValue(NAME,string);
putValue(SMALL_ICON,getIcon("icon.restart"));
}
public void actionPerformed(ActionEvent arg0) {
boolean logoutAvailable = getService(ClientService.class).isLogoutAvailable();
if ( logoutAvailable)
{
getService(ClientService.class).logout();
}
else
{
getService(ClientService.class).restart();
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.action;
import java.awt.event.ActionEvent;
import javax.swing.SwingUtilities;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaAction;
import org.rapla.storage.dbrm.RestartServer;
public class RestartServerAction extends RaplaAction {
/**
* @param sm
* @throws RaplaException
*/
public RestartServerAction(RaplaContext sm) throws RaplaException {
super(sm);
putValue(NAME,getString("restart_server"));
putValue(SMALL_ICON,getIcon("icon.restart"));
}
public void actionPerformed(ActionEvent arg0) {
SwingUtilities.invokeLater( new Runnable() {
public void run() {
try {
RestartServer service = getService( RestartServer.class);
service.restartServer();
} catch (RaplaException ex) {
getLogger().error("Error restarting ", ex);
}
}
});
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.action;
import java.awt.Component;
import java.awt.Point;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
public class DynamicTypeAction extends RaplaObjectAction {
String classificationType;
public DynamicTypeAction(RaplaContext sm,Component parent) {
super(sm,parent);
}
public DynamicTypeAction(RaplaContext sm,Component parent,Point p) {
super(sm,parent,p);
}
public DynamicTypeAction setNewClassificationType(String classificationType) {
this.classificationType = classificationType;
super.setNew( null );
return this;
}
protected void newEntity() throws RaplaException {
DynamicType newDynamicType = getModification().newDynamicType(classificationType);
getEditController().edit(newDynamicType, parent);
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.action;
import java.awt.Component;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.rapla.entities.Category;
import org.rapla.entities.Entity;
import org.rapla.entities.RaplaType;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Period;
import org.rapla.entities.domain.Reservation;
import org.rapla.entities.dynamictype.Classifiable;
import org.rapla.entities.dynamictype.Classification;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.entities.dynamictype.DynamicTypeAnnotations;
import org.rapla.facade.ModificationModule;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaAction;
import org.rapla.gui.internal.edit.DeleteUndo;
import org.rapla.gui.toolkit.DialogUI;
public class RaplaObjectAction extends RaplaAction {
public final static int DELETE = 1;
public final static int COPY = 2;
public final static int PASTE = 3;
public final static int CUT = 4;
public final static int NEW = 5;
public final static int EDIT = 6;
public final static int VIEW = 7;
public final static int DELETE_SELECTION = 8;
public final static int EDIT_SELECTION = 9; // new attribute to define a
// edit selection (several
// editable entities)
protected Component parent;
Point point;
protected int type;
boolean isPerson;
protected Entity<?> object;
Collection<Entity<?>> objectList;
protected RaplaType raplaType;
public RaplaObjectAction(RaplaContext sm) {
this(sm,null);
}
public RaplaObjectAction(RaplaContext sm,Component parent) {
this(sm,parent,null);
}
public RaplaObjectAction(RaplaContext sm,Component parent,Point point) {
super( sm);
this.parent = parent;
this.point = point;
}
public RaplaObjectAction setNew(RaplaType raplaType) {
this.raplaType = raplaType;
this.type = NEW;
putValue(NAME, getString("new"));
putValue(SMALL_ICON, getIcon("icon.new"));
update();
return this;
}
public RaplaObjectAction setDelete(Entity<?> object) {
this.type = DELETE;
putValue(NAME, getString("delete"));
putValue(SMALL_ICON, getIcon("icon.delete"));
changeObject(object);
return this;
}
public RaplaObjectAction setDeleteSelection(Collection<Entity<?>> selection) {
this.type = DELETE_SELECTION;
putValue(NAME, getString("delete_selection"));
putValue(SMALL_ICON, getIcon("icon.delete"));
this.objectList = new ArrayList<Entity<?>>(selection);
update();
return this;
}
public RaplaObjectAction setView(Entity<?> object) {
this.type = VIEW;
putValue(NAME, getString("view"));
putValue(SMALL_ICON, getIcon("icon.help"));
changeObject(object);
return this;
}
public RaplaObjectAction setEdit(Entity<?> object) {
this.type = EDIT;
putValue(NAME, getString("edit"));
putValue(SMALL_ICON, getIcon("icon.edit"));
changeObject(object);
return this;
}
// method for setting a selection as a editable selection
// (cf. setEdit() and setDeleteSelection())
public RaplaObjectAction setEditSelection(Collection<Entity<?>> selection) {
this.type = EDIT_SELECTION;
putValue(NAME, getString("edit"));
putValue(SMALL_ICON, getIcon("icon.edit"));
this.objectList = new ArrayList<Entity<?>>(selection);
update();
return this;
}
public void changeObject(Entity<?> object) {
this.object = object;
if (type == DELETE) {
if (object == null)
putValue(NAME, getString("delete"));
else
putValue(NAME, getI18n().format("delete.format",getName(object)));
}
update();
}
protected void update() {
boolean enabled = true;
if (type == EDIT || type == DELETE) {
enabled = canModify(object);
} else if (type == NEW ) {
enabled = (raplaType != null && raplaType.is(Allocatable.TYPE) && isRegisterer()) || isAdmin();
} else if (type == EDIT_SELECTION || type == DELETE_SELECTION) {
if (objectList != null && objectList.size() > 0 ) {
Iterator<Entity<?>> it = objectList.iterator();
while (it.hasNext()) {
if (!canModify(it.next())){
enabled = false;
break;
}
}
} else {
enabled = false;
}
}
setEnabled(enabled);
}
public void actionPerformed(ActionEvent evt) {
try {
switch (type) {
case DELETE: delete();break;
case DELETE_SELECTION: deleteSelection();break;
case EDIT: edit();break;
// EditSelection() as reaction of actionPerformed (click on the edit
// button)
case EDIT_SELECTION:editSelection();break;
case NEW: newEntity();break;
case VIEW: view();break;
}
} catch (RaplaException ex) {
showException(ex,parent);
} // end of try-catch
}
public void view() throws RaplaException {
getInfoFactory().showInfoDialog(object,parent);
}
protected Entity<? extends Entity<?>> newEntity(RaplaType raplaType) throws RaplaException {
ModificationModule m = getModification();
if ( Reservation.TYPE.is( raplaType ))
{
DynamicType type = guessType();
final Classification newClassification = type.newClassification();
Reservation newReservation = m.newReservation( newClassification );
return newReservation;
}
if ( Allocatable.TYPE.is( raplaType ))
{
DynamicType type = guessType();
final Classification newClassification = type.newClassification();
Allocatable allocatable = m.newAllocatable( newClassification );
return allocatable ;
}
if ( Category.TYPE.is( raplaType ))
return m.newCategory(); //will probably never happen
if ( User.TYPE.is( raplaType ))
return m.newUser();
if ( Period.TYPE.is( raplaType ))
return m.newPeriod();
throw new RaplaException("Can't create Entity for " + raplaType + "!");
}
/** guesses the DynamicType for the new object depending on the selected element.
<li>If the selected element is a DynamicType-Folder the DynamicType will be returned.
<li>If the selected element has a Classification the appropriatie DynamicType will be returned.
<li>else the first matching DynamicType for the passed classificationType will be returned.
<li>null if none of the above criterias matched.
*/
public DynamicType guessType() throws RaplaException {
DynamicType[] types = guessTypes();
if ( types.length > 0)
{
return types[0];
}
else
{
return null;
}
}
public DynamicType[] guessTypes() throws RaplaException {
DynamicType dynamicType = null;
getLogger().debug("Guessing DynamicType from " + object);
if (object instanceof DynamicType)
dynamicType = (DynamicType) object;
if (object instanceof Classifiable) {
Classification classification= ((Classifiable) object).getClassification();
dynamicType = classification.getType();
}
if (dynamicType != null)
{
return new DynamicType[] {dynamicType};
}
String classificationType = null;
if ( Reservation.TYPE.is( raplaType )) {
classificationType = DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESERVATION;
} else if ( Allocatable.TYPE.is( raplaType )) {
if ( isPerson ) {
classificationType = DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON;
} else {
classificationType = DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESOURCE;
}
}
DynamicType[] dynamicTypes = getQuery().getDynamicTypes( classificationType );
return dynamicTypes;
}
protected void newEntity() throws RaplaException {
if ( Category.TYPE.is( raplaType )) {
Category category = (Category)object;
getEditController().editNew(category, parent );
} else {
Entity<? extends Entity> obj = newEntity(raplaType);
getEditController().edit(obj, parent);
}
}
protected void edit() throws RaplaException {
getEditController().edit(object, parent);
}
protected void delete() throws RaplaException {
if (object == null)
return;
Entity<?>[] objects = new Entity[] { object};
DialogUI dlg = getInfoFactory().createDeleteDialog( objects, parent);
dlg.start();
if (dlg.getSelectedIndex() != 0)
return;
List<Entity<?>> singletonList = Arrays.asList( objects);
delete(singletonList);
}
protected void deleteSelection() throws RaplaException
{
if (objectList == null || objectList.size() == 0)
return;
DialogUI dlg = getInfoFactory().createDeleteDialog(objectList.toArray(), parent);
dlg.start();
if (dlg.getSelectedIndex() != 0)
return;
delete(objectList);
}
protected void delete(Collection<Entity<?>> objects) throws RaplaException
{
Collection<Entity<?>> entities = new ArrayList<Entity<?>>();
boolean undoable = true;
for ( Entity<?> obj: objects)
{
entities.add( obj);
RaplaType<?> raplaType = obj.getRaplaType();
if ( raplaType == User.TYPE || raplaType == DynamicType.TYPE)
{
undoable = false;
}
}
@SuppressWarnings({ "rawtypes", "unchecked" })
DeleteUndo<? extends Entity<?>> deleteCommand = new DeleteUndo(getContext(), entities);
if ( undoable)
{
getModification().getCommandHistory().storeAndExecute(deleteCommand);
}
else
{
deleteCommand.execute();
}
}
// action which is executed by clicking on the edit button (after
// actionPerformed)
// chances the selection list in an array and commits it on EditController
protected void editSelection() throws RaplaException {
if (objectList == null || objectList.size() == 0)
return;
Entity[] array = objectList.toArray(Entity.ENTITY_ARRAY);
getEditController().edit(array, parent);
}
public void setPerson(boolean b) {
isPerson = b;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.action;
import java.awt.event.ActionEvent;
import javax.swing.JMenuItem;
import org.rapla.entities.User;
import org.rapla.entities.configuration.Preferences;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.framework.TypedComponentRole;
import org.rapla.gui.RaplaAction;
import org.rapla.gui.toolkit.RaplaMenuItem;
public class SaveableToggleAction extends RaplaAction {
TypedComponentRole<Boolean> configEntry;
String name;
public SaveableToggleAction(RaplaContext context,String name,TypedComponentRole<Boolean> configEntry)
{
super( context );
this.name = name;
putValue( NAME, getString( name));
this.configEntry = configEntry;
//putValue(SMALL_ICON,getIcon("icon.unchecked"));
}
public RaplaMenuItem createMenuItem() throws RaplaException
{
RaplaMenuItem menu = new RaplaMenuItem(name);
menu.setAction( this);
final User user = getUser();
final Preferences preferences = getQuery().getPreferences( user );
boolean selected = preferences.getEntryAsBoolean( configEntry , true);
if(selected) {
menu.setSelected(true);
menu.setIcon(getIcon("icon.checked"));
}
else {
menu.setSelected(false);
menu.setIcon(getIcon("icon.unchecked"));
}
return menu;
}
public void actionPerformed(ActionEvent evt) {
toggleCheckbox((JMenuItem)evt.getSource());
}
public void toggleCheckbox(JMenuItem toolTip) {
boolean newSelected = !toolTip.isSelected();
if ( isModifyPreferencesAllowed())
{
try {
Preferences prefs = this.newEditablePreferences();
prefs.putEntry( configEntry, newSelected);
getModification().store( prefs);
} catch (Exception ex) {
showException( ex, null );
return;
}
}
toolTip.setSelected(newSelected);
javax.swing.ToolTipManager.sharedInstance().setEnabled(newSelected);
toolTip.setIcon(newSelected ? getIcon("icon.checked"):getIcon("icon.unchecked"));
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Window;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyVetoException;
import java.beans.VetoableChangeListener;
import javax.swing.Box;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JMenuBar;
import javax.swing.JPanel;
import org.rapla.RaplaMainContainer;
import org.rapla.client.ClientService;
import org.rapla.entities.User;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.facade.ModificationEvent;
import org.rapla.facade.ModificationListener;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.common.InternMenus;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.RaplaFrame;
public class MainFrame extends RaplaGUIComponent
implements
ModificationListener
{
RaplaMenuBar menuBar;
RaplaFrame frame = null;
Listener listener = new Listener();
CalendarEditor cal;
JLabel statusBar = new JLabel("");
public MainFrame(RaplaContext sm) throws RaplaException {
super(sm);
menuBar = new RaplaMenuBar(getContext());
frame = getService( ClientService.MAIN_COMPONENT );
String title = getQuery().getSystemPreferences().getEntryAsString(RaplaMainContainer.TITLE, getString("rapla.title"));
// CKO TODO Title should be set in config along with the facade used
frame.setTitle(title );
CalendarSelectionModel model = getService( CalendarSelectionModel.class);
cal = new CalendarEditor(sm,model);
getUpdateModule().addModificationListener(this);
JMenuBar menuBar = getService( InternMenus.MENU_BAR);
menuBar.add(Box.createHorizontalGlue());
menuBar.add(statusBar);
menuBar.add(Box.createHorizontalStrut(5));
frame.setJMenuBar( menuBar );
getContentPane().setLayout( new BorderLayout() );
// getContentPane().add ( statusBar, BorderLayout.SOUTH);
getContentPane().add( cal.getComponent() , BorderLayout.CENTER );
}
public void show() {
getLogger().debug("Creating Main-Frame");
createFrame();
//dataChanged(null);
setStatus();
cal.start();
frame.setIconImage(getI18n().getIcon("icon.rapla_small").getImage());
frame.setVisible(true);
getFrameList().setMainWindow(frame);
}
private JPanel getContentPane() {
return (JPanel) frame.getContentPane();
}
private void createFrame() {
Dimension dimension = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
frame.setSize(new Dimension(
Math.min(dimension.width,1200)
,Math.min(dimension.height-20,900)
)
);
frame.addVetoableChangeListener(listener);
//statusBar.setBorder( BorderFactory.createEtchedBorder());
}
class Listener implements VetoableChangeListener {
public void vetoableChange(PropertyChangeEvent evt) throws PropertyVetoException {
if (shouldExit())
close();
else
throw new PropertyVetoException("Don't close",evt);
}
}
public Window getFrame() {
return frame;
}
public JComponent getComponent() {
return (JComponent) frame.getContentPane();
}
public void dataChanged(ModificationEvent e) throws RaplaException {
cal.dataChanged( e );
new StatusFader(statusBar).updateStatus();
}
private void setStatus() {
statusBar.setMaximumSize( new Dimension(400,20));
final StatusFader runnable = new StatusFader(statusBar);
final Thread fadeThread = new Thread(runnable);
fadeThread.setDaemon( true);
fadeThread.start();
}
class StatusFader implements Runnable{
JLabel label;
StatusFader(JLabel label)
{
this.label=label;
}
public void run() {
try {
{
User user = getUser();
final boolean admin = user.isAdmin();
String name = user.getName();
if ( name == null || name.length() == 0 )
{
name = user.getUsername();
}
String message = getI18n().format("rapla.welcome",name);
if ( admin)
{
message = message + " " + getString("admin.login");
}
statusBar.setText(message);
fadeIn( statusBar );
}
Thread.sleep(2000);
{
fadeOut( statusBar);
if (getUserModule().isSessionActive())
{
updateStatus();
}
fadeIn( statusBar );
}
} catch (InterruptedException ex) {
//Logger.getLogger(Fader.class.getName()).log(Level.SEVERE, null, ex);
} catch (RaplaException e) {
}
}
public void updateStatus() throws RaplaException {
User user = getUser();
final boolean admin = user.isAdmin();
String message = getString("user") + " "+ user.toString();
String templateName = getModification().getTemplateName();
if ( templateName != null)
{
message = getString("edit-templates") + " [" + templateName + "] " + message;
}
statusBar.setText( message);
final Font boldFont = statusBar.getFont().deriveFont(Font.BOLD);
statusBar.setFont( boldFont);
if ( admin)
{
statusBar.setForeground( new Color(220,30,30));
}
else
{
statusBar.setForeground( new Color(30,30,30) );
}
}
private void fadeIn(JLabel label) throws InterruptedException {
int alpha=0;
Color c = label.getForeground();
while(alpha<=230){
alpha+=25;
final Color color = new Color(c.getRed(), c.getGreen(), c.getBlue(), alpha);
label.setForeground(color);
label.repaint();
Thread.sleep(200);
}
}
private void fadeOut(JLabel label) throws InterruptedException {
int alpha=250;
Color c = label.getForeground();
while(alpha>0){
alpha-=25;
final Color color = new Color(c.getRed(), c.getGreen(), c.getBlue(), alpha);
label.setForeground(color);
label.repaint();
Thread.sleep(200);
}
}
}
protected boolean shouldExit() {
try {
DialogUI dlg = DialogUI.create(getContext()
,frame.getRootPane()
,true
,getString("exit.title")
,getString("exit.question")
,new String[] {
getString("exit.ok")
,getString("exit.abort")
}
);
dlg.setIcon(getIcon("icon.question"));
//dlg.getButton(0).setIcon(getIcon("icon.confirm"));
dlg.getButton(0).setIcon(getIcon("icon.abort"));
dlg.setDefault(1);
dlg.start();
return (dlg.getSelectedIndex() == 0);
} catch (RaplaException e) {
getLogger().error( e.getMessage(), e);
return true;
}
}
public void close() {
getUpdateModule().removeModificationListener(this);
frame.close();
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.util.Locale;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import org.rapla.RaplaMainContainer;
import org.rapla.components.calendar.RaplaNumber;
import org.rapla.components.layout.TableLayout;
import org.rapla.entities.configuration.Preferences;
import org.rapla.facade.CalendarModel;
import org.rapla.facade.UpdateModule;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.OptionPanel;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.plugin.export2ical.ICalTimezones;
public class RaplaStartOption extends RaplaGUIComponent implements OptionPanel {
JPanel panel = new JPanel();
JTextField calendarName;
Preferences preferences;
private JComboBox cboTimezone;
ICalTimezones timezoneService;
private JCheckBox ownReservations;
RaplaNumber seconds = new RaplaNumber(new Double(10),new Double(10),null, false);
public RaplaStartOption(RaplaContext context, ICalTimezones timezoneService) throws RaplaException {
super( context );
double pre = TableLayout.PREFERRED;
panel.setLayout( new TableLayout(new double[][] {{pre, 5,pre, 5, pre}, {pre,5,pre, 5 , pre, 5, pre}}));
this.timezoneService = timezoneService;
calendarName = new JTextField();
addCopyPaste( calendarName);
calendarName.setColumns(20);
panel.add( new JLabel(getString("custom_applicationame")),"0,0" );
panel.add( calendarName,"2,0");
calendarName.setEnabled(true);
String[] timeZoneIDs = getTimeZonesFromResource();
panel.add(new JLabel(getString("timezone")), "0,2");
@SuppressWarnings("unchecked")
JComboBox jComboBox = new JComboBox(timeZoneIDs);
cboTimezone = jComboBox;
panel.add(cboTimezone, "2,2");
cboTimezone.setEditable(false);
panel.add(new JLabel( getString("defaultselection") + " '" + getString("only_own_reservations") +"'"), "0,4");
ownReservations = new JCheckBox();
panel.add(ownReservations, "2,4");
seconds.getNumberField().setBlockStepSize( 60);
seconds.getNumberField().setStepSize( 10);
panel.add( new JLabel(getString("seconds")),"4,6" );
panel.add( seconds,"2,6");
panel.add( new JLabel(getString("connection") + ": " + getI18n().format("interval.format", "","")),"0,6" );
addCopyPaste( seconds.getNumberField());
}
public JComponent getComponent() {
return panel;
}
public String getName(Locale locale) {
return getString("options");
}
public void setPreferences( Preferences preferences) {
this.preferences = preferences;
}
public void show() throws RaplaException {
String name = preferences.getEntryAsString( RaplaMainContainer.TITLE,"");
calendarName.setText(name);
try {
String timezoneId = preferences.getEntryAsString( RaplaMainContainer.TIMEZONE,timezoneService.getDefaultTimezone().get());
cboTimezone.setSelectedItem(timezoneId);
}
catch (RaplaException ex)
{
throw ex;
}
catch (Exception ex)
{
throw new RaplaException(ex);
}
boolean selected= preferences.getEntryAsBoolean( CalendarModel.ONLY_MY_EVENTS_DEFAULT, true);
ownReservations.setSelected( selected);
int delay = preferences.getEntryAsInteger( UpdateModule.REFRESH_INTERVAL_ENTRY, UpdateModule.REFRESH_INTERVAL_DEFAULT);
seconds.setNumber( new Long(delay / 1000));
seconds.setEnabled(getClientFacade().isClientForServer());
}
public void commit() {
String title = calendarName.getText();
if ( title.trim().length() > 0)
{
preferences.putEntry( RaplaMainContainer.TITLE,title );
}
else
{
preferences.putEntry( RaplaMainContainer.TITLE, (String)null);
}
String timeZoneId = String.valueOf(cboTimezone.getSelectedItem());
preferences.putEntry( RaplaMainContainer.TIMEZONE, timeZoneId);
boolean selected= ownReservations.isSelected();
preferences.putEntry( CalendarModel.ONLY_MY_EVENTS_DEFAULT, selected);
int delay = seconds.getNumber().intValue() * 1000;
preferences.putEntry( UpdateModule.REFRESH_INTERVAL_ENTRY, delay );
}
/**
* Gets all the iCal4J supported TimeZones from the Resource File They are
* generated by trial-and error in the BUILD event.
*
* @return String[] of the TimeZones for direct use in the ComboBox
* @throws RaplaException
*/
private String[] getTimeZonesFromResource() throws RaplaException
{
try
{
String zoneString = timezoneService.getICalTimezones().get();
return zoneString.split(";");
}
catch (RaplaException ex)
{
throw ex;
}
catch (Exception ex)
{
throw new RaplaException(ex);
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.Component;
import java.awt.FlowLayout;
import java.util.Calendar;
import java.util.Locale;
import javax.swing.BoxLayout;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import org.rapla.components.calendar.DateChangeEvent;
import org.rapla.components.calendar.DateChangeListener;
import org.rapla.components.calendar.RaplaNumber;
import org.rapla.components.calendar.RaplaTime;
import org.rapla.components.calendarview.WeekdayMapper;
import org.rapla.components.layout.TableLayout;
import org.rapla.entities.configuration.Preferences;
import org.rapla.entities.configuration.RaplaConfiguration;
import org.rapla.facade.CalendarOptions;
import org.rapla.facade.internal.CalendarOptionsImpl;
import org.rapla.framework.DefaultConfiguration;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.OptionPanel;
import org.rapla.gui.RaplaGUIComponent;
public class CalendarOption extends RaplaGUIComponent implements OptionPanel, DateChangeListener
{
JPanel panel = new JPanel();
JCheckBox showExceptionsField = new JCheckBox();
@SuppressWarnings("unchecked")
JComboBox colorBlocks = new JComboBox( new String[] {
CalendarOptionsImpl.COLOR_NONE
,CalendarOptionsImpl.COLOR_RESOURCES
, CalendarOptionsImpl.COLOR_EVENTS
, CalendarOptionsImpl.COLOR_EVENTS_AND_RESOURCES
}
);
RaplaNumber rowsPerHourField = new RaplaNumber(new Double(1),new Double(1),new Double(12), false);
Preferences preferences;
CalendarOptions options;
RaplaTime worktimeStart;
RaplaTime worktimeEnd;
JPanel excludeDaysPanel = new JPanel();
JCheckBox[] box = new JCheckBox[7];
WeekdayMapper mapper;
RaplaNumber nTimesField = new RaplaNumber(new Double(1),new Double(1),new Double(365), false);
@SuppressWarnings({ "unchecked" })
JComboBox nonFilteredEvents = new JComboBox( new String[]
{
CalendarOptionsImpl.NON_FILTERED_EVENTS_TRANSPARENT,
CalendarOptionsImpl.NON_FILTERED_EVENTS_HIDDEN
}
);
JLabel worktimeEndError;
@SuppressWarnings({ "unchecked" })
JComboBox minBlockWidth = new JComboBox( new Integer[] {0,50,100,200});
JComboBox firstDayOfWeek;
RaplaNumber daysInWeekview;
public CalendarOption(RaplaContext sm) {
super( sm);
daysInWeekview = new RaplaNumber(7, 3, 35, false);
mapper = new WeekdayMapper(getLocale());
worktimeStart = createRaplaTime();
worktimeStart.setRowsPerHour( 1 );
worktimeEnd = createRaplaTime();
worktimeEnd.setRowsPerHour( 1 );
double pre = TableLayout.PREFERRED;
double fill = TableLayout.FILL;
// rows = 8 columns = 4
panel.setLayout( new TableLayout(new double[][] {{pre, 5, pre, 5 , pre, 5, pre}, {pre,5,pre,5,pre,5,pre,5,pre,5,pre,5,pre,5,pre,5,pre,5,pre,5,pre,5,pre,5,pre,5,fill}}));
panel.add( new JLabel(getString("rows_per_hour")),"0,0" );
panel.add( rowsPerHourField,"2,0");
panel.add( new JLabel(getString("start_time")),"0,2" );
JPanel worktimeStartPanel = new JPanel();
worktimeStartPanel.add( worktimeStart);
panel.add( worktimeStartPanel, "2,2,l");
panel.add( new JLabel(getString("end_time")),"0,4" );
worktimeStart.addDateChangeListener(this);
JPanel worktimeEndPanel = new JPanel();
panel.add( worktimeEndPanel,"2,4,l");
worktimeEndPanel.add( worktimeEnd);
worktimeEndError = new JLabel(getString("appointment.next_day"));
worktimeEndPanel.add( worktimeEndError);
worktimeEnd.addDateChangeListener(this);
panel.add( new JLabel(getString("color")),"0,6" );
panel.add( colorBlocks,"2,6");
showExceptionsField.setText("");
panel.add( new JLabel(getString("display_exceptions")),"0,8");
panel.add( showExceptionsField,"2,8");
panel.add( new JLabel(getString("events_not_matched_by_filter")),"0,10");
panel.add( nonFilteredEvents,"2,10");
setRenderer();
@SuppressWarnings("unchecked")
JComboBox jComboBox = new JComboBox(mapper.getNames());
firstDayOfWeek = jComboBox;
panel.add( new JLabel(getString("day1week")),"0,12");
panel.add( firstDayOfWeek,"2,12");
panel.add( new JLabel(getString("daysInWeekview")),"0,14");
panel.add( daysInWeekview,"2,14");
panel.add( new JLabel(getString("minimumBlockWidth")),"0,16");
JPanel minWidthContainer = new JPanel();
minWidthContainer.setLayout( new FlowLayout(FlowLayout.LEFT));
minWidthContainer.add(minBlockWidth);
minWidthContainer.add(new JLabel("%"));
panel.add( minWidthContainer,"2,16");
panel.add( new JLabel(getString("exclude_days")),"0,22,l,t");
panel.add( excludeDaysPanel,"2,22");
excludeDaysPanel.setLayout( new BoxLayout( excludeDaysPanel,BoxLayout.Y_AXIS));
for ( int i=0;i<box.length;i++) {
int weekday = mapper.dayForIndex( i);
box[i] = new JCheckBox(mapper.getName(weekday));
excludeDaysPanel.add( box[i]);
}
}
@SuppressWarnings("unchecked")
private void setRenderer() {
ListRenderer listRenderer = new ListRenderer();
nonFilteredEvents.setRenderer( listRenderer );
colorBlocks.setRenderer( listRenderer );
}
public JComponent getComponent() {
return panel;
}
public String getName(Locale locale) {
return getString("calendar");
}
public void setPreferences( Preferences preferences) {
this.preferences = preferences;
}
public void show() throws RaplaException {
// get the options
RaplaConfiguration config = preferences.getEntry( CalendarOptionsImpl.CALENDAR_OPTIONS);
if ( config != null) {
options = new CalendarOptionsImpl( config );
} else {
options = getCalendarOptions();
}
if ( options.isEventColoring() && options.isResourceColoring())
{
colorBlocks.setSelectedItem( CalendarOptionsImpl.COLOR_EVENTS_AND_RESOURCES);
}
else if ( options.isEventColoring() )
{
colorBlocks.setSelectedItem( CalendarOptionsImpl.COLOR_EVENTS);
}
else if ( options.isResourceColoring())
{
colorBlocks.setSelectedItem( CalendarOptionsImpl.COLOR_RESOURCES);
}
else
{
colorBlocks.setSelectedItem( CalendarOptionsImpl.COLOR_NONE);
}
showExceptionsField.setSelected( options.isExceptionsVisible());
rowsPerHourField.setNumber( new Long(options.getRowsPerHour()));
Calendar calendar = getRaplaLocale().createCalendar();
int workTime = options.getWorktimeStartMinutes();
calendar.set( Calendar.HOUR_OF_DAY, workTime / 60);
calendar.set( Calendar.MINUTE, workTime % 60);
worktimeStart.setTime( calendar.getTime() );
workTime = options.getWorktimeEndMinutes();
calendar.set( Calendar.HOUR_OF_DAY, workTime / 60);
calendar.set( Calendar.MINUTE, workTime % 60);
worktimeEnd.setTime( calendar.getTime() );
for ( int i=0;i<box.length;i++) {
int weekday = mapper.dayForIndex( i);
box[i].setSelected( options.getExcludeDays().contains( new Integer( weekday)));
}
int firstDayOfWeek2 = options.getFirstDayOfWeek();
firstDayOfWeek.setSelectedIndex( mapper.indexForDay( firstDayOfWeek2));
daysInWeekview.setNumber( options.getDaysInWeekview());
minBlockWidth.setSelectedItem( new Integer(options.getMinBlockWidth()));
nonFilteredEvents.setSelectedItem( options.isNonFilteredEventsVisible() ? CalendarOptionsImpl.NON_FILTERED_EVENTS_TRANSPARENT : CalendarOptionsImpl.NON_FILTERED_EVENTS_HIDDEN);
}
public void commit() {
// Save the options
RaplaConfiguration calendarOptions = new RaplaConfiguration("calendar-options");
DefaultConfiguration worktime = new DefaultConfiguration(CalendarOptionsImpl.WORKTIME);
DefaultConfiguration excludeDays = new DefaultConfiguration(CalendarOptionsImpl.EXCLUDE_DAYS);
DefaultConfiguration rowsPerHour = new DefaultConfiguration(CalendarOptionsImpl.ROWS_PER_HOUR);
DefaultConfiguration exceptionsVisible = new DefaultConfiguration(CalendarOptionsImpl.EXCEPTIONS_VISIBLE);
DefaultConfiguration daysInWeekview = new DefaultConfiguration(CalendarOptionsImpl.DAYS_IN_WEEKVIEW);
DefaultConfiguration firstDayOfWeek = new DefaultConfiguration(CalendarOptionsImpl.FIRST_DAY_OF_WEEK);
DefaultConfiguration minBlockWidth = new DefaultConfiguration(CalendarOptionsImpl.MIN_BLOCK_WIDTH);
daysInWeekview.setValue( this.daysInWeekview.getNumber().intValue());
int selectedIndex = this.firstDayOfWeek.getSelectedIndex();
int weekday = mapper.dayForIndex(selectedIndex);
firstDayOfWeek.setValue( weekday);
DefaultConfiguration colorBlocks = new DefaultConfiguration(CalendarOptionsImpl.COLOR_BLOCKS);
String colorValue = (String) this.colorBlocks.getSelectedItem();
if ( colorValue != null )
{
colorBlocks.setValue( colorValue );
}
calendarOptions.addChild( colorBlocks );
Calendar calendar = getRaplaLocale().createCalendar();
calendar.setTime( worktimeStart.getTime());
int worktimeStartHour = calendar.get(Calendar.HOUR_OF_DAY) ;
int worktimeStartMinute = calendar.get(Calendar.MINUTE);
calendar.setTime( worktimeEnd.getTime());
int worktimeEndHour = calendar.get(Calendar.HOUR_OF_DAY) ;
int worktimeEndMinute = calendar.get(Calendar.MINUTE);
if ( worktimeStartMinute > 0 || worktimeEndMinute > 0)
{
worktime.setValue( worktimeStartHour + ":" + worktimeStartMinute + "-" + worktimeEndHour + ":" + worktimeEndMinute );
}
else
{
worktime.setValue( worktimeStartHour + "-" + worktimeEndHour );
}
calendarOptions.addChild( worktime);
exceptionsVisible.setValue( showExceptionsField.isSelected() );
calendarOptions.addChild( exceptionsVisible);
rowsPerHour.setValue( rowsPerHourField.getNumber().intValue());
StringBuffer days = new StringBuffer();
for ( int i=0;i<box.length;i++) {
if (box[i].isSelected()) {
if ( days.length() > 0)
days.append(",");
days.append( mapper.dayForIndex( i ));
}
}
calendarOptions.addChild( rowsPerHour);
excludeDays.setValue( days.toString());
calendarOptions.addChild( excludeDays);
calendarOptions.addChild(daysInWeekview);
calendarOptions.addChild(firstDayOfWeek);
Object selectedItem = this.minBlockWidth.getSelectedItem();
if ( selectedItem != null)
{
minBlockWidth.setValue( (Integer) selectedItem);
calendarOptions.addChild(minBlockWidth);
}
DefaultConfiguration nonFilteredEventsConfig = new DefaultConfiguration(CalendarOptionsImpl.NON_FILTERED_EVENTS);
nonFilteredEventsConfig.setValue( nonFilteredEvents.getSelectedItem().toString());
calendarOptions.addChild( nonFilteredEventsConfig);
preferences.putEntry( CalendarOptionsImpl.CALENDAR_OPTIONS, calendarOptions);
}
public void dateChanged(DateChangeEvent evt) {
Calendar calendar = getRaplaLocale().createCalendar();
calendar.setTime( worktimeStart.getTime());
int worktimeS = calendar.get(Calendar.HOUR_OF_DAY)*60 + calendar.get(Calendar.MINUTE);
calendar.setTime( worktimeEnd.getTime());
int worktimeE = calendar.get(Calendar.HOUR_OF_DAY)*60 + calendar.get(Calendar.MINUTE);
worktimeE = (worktimeE == 0)?24*60:worktimeE;
boolean overnight = worktimeS >= worktimeE|| worktimeE == 24*60;
worktimeEndError.setVisible( overnight);
}
private class ListRenderer extends DefaultListCellRenderer {
private static final long serialVersionUID = 1L;
public Component getListCellRendererComponent(
//@SuppressWarnings("rawtypes")
JList list
,Object value, int index, boolean isSelected, boolean cellHasFocus) {
if ( value != null) {
setText(getString( value.toString()));
}
return this;
}
}
} | Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.common;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.rapla.client.RaplaClientExtensionPoints;
import org.rapla.components.calendar.RaplaArrowButton;
import org.rapla.components.layout.TableLayout;
import org.rapla.components.util.TimeInterval;
import org.rapla.entities.RaplaObject;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.facade.ModificationEvent;
import org.rapla.framework.Disposable;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.SwingCalendarView;
import org.rapla.gui.SwingViewFactory;
import org.rapla.gui.VisibleTimeInterval;
import org.rapla.gui.internal.CalendarEditor;
import org.rapla.gui.internal.FilterEditButton;
import org.rapla.gui.internal.edit.ClassifiableFilterEdit;
import org.rapla.gui.toolkit.IdentifiableMenuEntry;
import org.rapla.gui.toolkit.RaplaMenu;
import org.rapla.gui.toolkit.RaplaMenuItem;
import org.rapla.gui.toolkit.RaplaWidget;
public class MultiCalendarView extends RaplaGUIComponent
implements
RaplaWidget, Disposable, ChangeListener
{
private final JPanel page = new JPanel();
private final JPanel header = new JPanel();
Map<String,RaplaMenuItem> viewMenuItems = new HashMap<String,RaplaMenuItem>();
JComboBox viewChooser;
List<ChangeListener> listeners = new ArrayList<ChangeListener>();
// Default view, when no plugin defined
String ERROR_NO_VIEW_DEFINED = "No views enabled. Please add a plugin in the menu admin/settings/plugins";
private SwingCalendarView defaultView = new SwingCalendarView() {
JLabel noViewDefined = new JLabel(ERROR_NO_VIEW_DEFINED);
JPanel test =new JPanel();
{
test.add( noViewDefined);
}
public JComponent getDateSelection()
{
return null;
}
public void scrollToStart()
{
}
public JComponent getComponent()
{
return test;
}
public void update( ) throws RaplaException
{
}
};
private SwingCalendarView currentView = defaultView;
String currentViewId;
private final CalendarSelectionModel model;
final Collection<SwingViewFactory> factoryList;
/** renderer for weekdays in month-view */
boolean editable = true;
boolean listenersEnabled = true;
FilterEditButton filter;
CalendarEditor calendarEditor;
public MultiCalendarView(RaplaContext context,CalendarSelectionModel model, CalendarEditor calendarEditor) throws RaplaException {
this( context, model, true);
this.calendarEditor = calendarEditor;
}
public MultiCalendarView(RaplaContext context,CalendarSelectionModel model, boolean editable) throws RaplaException {
super( context);
this.editable = editable;
factoryList = getContainer().lookupServicesFor(RaplaClientExtensionPoints.CALENDAR_VIEW_EXTENSION);
this.model = model;
String[] ids = getIds();
{
SwingViewFactory factory = findFactory( model.getViewId());
if ( factory == null)
{
if ( ids.length != 0 ) {
String firstId = ids[0];
model.setViewId( firstId );
factory = findFactory( firstId );
}
}
}
RaplaMenu view = getService( InternMenus.VIEW_MENU_ROLE);
if ( !view.hasId( "views") )
{
addMenu( model, ids, view );
}
addTypeChooser( ids );
header.setLayout(new BorderLayout());
header.add( viewChooser, BorderLayout.CENTER);
filter =new FilterEditButton(context,model, this, false);
final JPanel filterContainer = new JPanel();
filterContainer.setLayout( new BorderLayout());
filterContainer.add(filter.getButton(), BorderLayout.WEST);
header.add( filterContainer, BorderLayout.SOUTH);
page.setBackground( Color.white );
page.setLayout(new TableLayout( new double[][]{
{TableLayout.PREFERRED, TableLayout.FILL}
,{TableLayout.PREFERRED, TableLayout.FILL}}));
update(null);
}
public void dispose() {
}
@SuppressWarnings("unchecked")
private void addTypeChooser( String[] ids )
{
JComboBox jComboBox = new JComboBox( ids);
viewChooser = jComboBox;
viewChooser.setVisible( viewChooser.getModel().getSize() > 0);
viewChooser.setMaximumRowCount(ids.length);
viewChooser.setSelectedItem( getModel().getViewId() );
viewChooser.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent evt) {
if ( !listenersEnabled )
return;
String viewId = (String) ((JComboBox)evt.getSource()).getSelectedItem();
try {
selectView( viewId );
} catch (RaplaException ex) {
showException(ex, page);
}
}
}
);
viewChooser.setRenderer( new DefaultListCellRenderer() {
private static final long serialVersionUID = 1L;
public Component getListCellRendererComponent(JList arg0, Object selectedItem, int index, boolean arg3, boolean arg4) {
super.getListCellRendererComponent( arg0, selectedItem, index, arg3, arg4);
if ( selectedItem == null) {
setIcon( null );
} else {
SwingViewFactory factory = findFactory( (String)selectedItem);
setText( factory.getName() );
setIcon( factory.getIcon());
}
return this;
}
});
}
public void addValueChangeListener(ChangeListener changeListener) {
listeners .add( changeListener);
}
public void removeValueChangeListener(ChangeListener changeListener) {
listeners .remove( changeListener);
}
public RaplaArrowButton getFilterButton()
{
return filter.getButton();
}
public void stateChanged(ChangeEvent e) {
try {
ClassifiableFilterEdit filterUI = filter.getFilterUI();
if ( filterUI != null)
{
final ClassificationFilter[] filters = filterUI.getFilters();
model.setReservationFilter( filters );
update(null);
}
} catch (Exception ex) {
showException(ex, getComponent());
}
}
private void addMenu( CalendarSelectionModel model, String[] ids, RaplaMenu view )
{
RaplaMenu viewMenu = new RaplaMenu("views");
viewMenu.setText(getString("show_as"));
view.insertBeforeId( viewMenu, "show_tips");
ButtonGroup group = new ButtonGroup();
for (int i=0;i<ids.length;i++)
{
String id = ids[i];
RaplaMenuItem viewItem = new RaplaMenuItem( id);
if ( id.equals( model.getViewId()))
{
viewItem.setIcon( getIcon("icon.radio"));
}
else
{
viewItem.setIcon( getIcon("icon.empty"));
}
group.add( viewItem );
SwingViewFactory factory = findFactory( id );
viewItem.setText( factory.getName() );
viewMenu.add( viewItem );
viewItem.setSelected( id.equals( getModel().getViewId()));
viewMenuItems.put( id, viewItem );
viewItem.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent evt) {
if ( !listenersEnabled )
return;
String viewId = ((IdentifiableMenuEntry)evt.getSource()).getId();
try {
selectView( viewId );
} catch (RaplaException ex) {
showException(ex, page);
}
}
});
}
}
private SwingViewFactory findFactory(String id) {
for (Iterator<SwingViewFactory> it = factoryList.iterator();it.hasNext();) {
SwingViewFactory factory = it.next();
if ( factory.getViewId().equals( id ) ) {
return factory;
}
}
return null;
}
private void selectView(String viewId) throws RaplaException {
listenersEnabled = false;
try {
getModel().setViewId( viewId );
update(null);
getSelectedCalendar().scrollToStart();
if ( viewMenuItems.size() > 0) {
for ( Iterator<RaplaMenuItem> it = viewMenuItems.values().iterator();it.hasNext();)
{
RaplaMenuItem item = it.next();
item.setIcon( getIcon("icon.empty"));
}
RaplaMenuItem item = viewMenuItems.get( viewId );
item.setIcon( getIcon("icon.radio"));
}
for(ChangeListener listener:listeners)
{
listener.stateChanged( new ChangeEvent( this));
}
viewChooser.setSelectedItem( viewId );
} finally {
listenersEnabled = true;
}
}
private String[] getIds() {
List<SwingViewFactory> sortedList = new ArrayList<SwingViewFactory>(factoryList);
Collections.sort( sortedList, new Comparator<SwingViewFactory>() {
public int compare( SwingViewFactory arg0, SwingViewFactory arg1 )
{
SwingViewFactory f1 = arg0;
SwingViewFactory f2 = arg1;
return f1.getMenuSortKey().compareTo( f2.getMenuSortKey() );
}
});
List<String> list = new ArrayList<String>();
for (Iterator<SwingViewFactory> it = sortedList.iterator();it.hasNext();) {
SwingViewFactory factory = it.next();
list.add(factory.getViewId());
}
return list.toArray( RaplaObject.EMPTY_STRING_ARRAY);
}
public CalendarSelectionModel getModel() {
return model;
}
public void update(ModificationEvent evt) throws RaplaException {
try
{
// don't show filter button in template mode
filter.getButton().setVisible( getModification().getTemplateName() == null);
listenersEnabled = false;
String viewId = model.getViewId();
SwingViewFactory factory = findFactory( viewId );
if ( factory == null )
{
getLogger().error("View with id " + viewId + " not found. Selecting first view.");
if( factoryList.size() == 0)
{
getLogger().error(ERROR_NO_VIEW_DEFINED);
viewId =null;
}
else
{
factory = factoryList.iterator().next();
viewId = factory.getViewId();
}
}
if ( factory != null)
{
viewChooser.setSelectedItem( viewId );
}
else
{
viewId = "ERROR_VIEW";
}
if ( currentViewId == null || !currentViewId.equals( viewId) ) {
if ( factory != null)
{
currentView = factory.createSwingView( getContext(), model, editable);
currentViewId = viewId; }
else
{
currentView = defaultView;
currentViewId = "ERROR_VIEW";
}
page.removeAll();
page.add( header, "0,0,f,f");
JComponent dateSelection = currentView.getDateSelection();
if ( dateSelection != null)
page.add( dateSelection, "1,0,f,f" );
JComponent component = currentView.getComponent();
page.add( component, "0,1,1,1,f,f" );
component.setBorder( BorderFactory.createEtchedBorder());
page.setVisible(false);
page.invalidate();
page.setVisible( true);
} else {
boolean update = true;
if ( currentView instanceof VisibleTimeInterval)
{
TimeInterval visibleTimeInterval = ((VisibleTimeInterval) currentView).getVisibleTimeInterval();
if ( evt != null && !evt.isModified() && visibleTimeInterval != null)
{
TimeInterval invalidateInterval = evt.getInvalidateInterval();
if ( invalidateInterval != null && !invalidateInterval.overlaps( visibleTimeInterval))
{
update = false;
}
}
}
if ( update )
{
currentView.update( );
}
}
if ( calendarEditor != null)
{
calendarEditor.updateOwnReservationsSelected();
}
}
finally
{
listenersEnabled = true;
}
}
public SwingCalendarView getSelectedCalendar() {
return currentView;
}
public JComponent getComponent() {
return page;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.common;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Appointment;
import org.rapla.entities.domain.AppointmentStartComparator;
import org.rapla.entities.domain.Reservation;
import org.rapla.facade.ModificationEvent;
import org.rapla.facade.ModificationListener;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaGUIComponent;
public class RaplaClipboard extends RaplaGUIComponent implements ModificationListener
{
private Appointment appointment;
private Collection<Reservation> reservations = Collections.emptyList();
private boolean wholeReservation;
private Allocatable[] restrictedAllocatables;
private Collection<Allocatable> contextAllocatables = Collections.emptyList();
public RaplaClipboard( RaplaContext sm )
{
super( sm );
getUpdateModule().addModificationListener( this );
}
public void dataChanged( ModificationEvent evt ) throws RaplaException
{
if ( appointment == null )
return;
if ( evt.isRemoved( appointment) || evt.isRemoved( appointment.getReservation()))
{
clearAppointment();
}
}
private void clearAppointment()
{
this.appointment = null;
this.wholeReservation = false;
this.restrictedAllocatables = null;
this.reservations = Collections.emptyList();
this.contextAllocatables = Collections.emptyList();
}
public void setAppointment( Appointment appointment, boolean wholeReservation, Reservation destReservation, Allocatable[] restrictedAllocatables,Collection<Allocatable> contextAllocatables )
{
this.appointment = appointment;
this.wholeReservation = wholeReservation;
this.reservations = Collections.singleton(destReservation);
this.restrictedAllocatables = restrictedAllocatables;
this.contextAllocatables = contextAllocatables;
}
public void setReservation(Collection<Reservation> copyReservation, Collection<Allocatable> contextAllocatables)
{
ArrayList<Appointment> appointmentList = new ArrayList<Appointment>();
for (Reservation r:copyReservation)
{
appointmentList.addAll( Arrays.asList( r.getAppointments()));
}
Collections.sort( appointmentList, new AppointmentStartComparator());
appointment = appointmentList.get(0);
wholeReservation = true;
restrictedAllocatables = Allocatable.ALLOCATABLE_ARRAY;
reservations = copyReservation;
this.contextAllocatables = contextAllocatables;
}
public boolean isWholeReservation()
{
return wholeReservation;
}
public Appointment getAppointment()
{
return appointment;
}
public Allocatable[] getRestrictedAllocatables()
{
return restrictedAllocatables;
}
public Reservation getReservation()
{
if ( reservations == null || reservations.size() == 0)
{
return null;
}
return reservations.iterator().next();
}
public Collection<Reservation> getReservations()
{
return reservations;
}
public Collection<Allocatable> getConextAllocatables() {
return contextAllocatables;
}
public void setContextAllocatables(Collection<Allocatable> contextAllocatables) {
this.contextAllocatables = contextAllocatables;
}
}
/*
class AllocationData implements Transferable {
public static final DataFlavor allocationFlavor = new DataFlavor(java.util.Map.class, "Rapla Allocation");
private static DataFlavor[] flavors = new DataFlavor[] {allocationFlavor};
Map data;
AllocationData(Map data) {
this.data = data;
}
public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException {
if (isDataFlavorSupported(flavor))
return data;
else
throw new UnsupportedFlavorException(flavor);
}
public DataFlavor[] getTransferDataFlavors() {
return flavors;
}
public boolean isDataFlavorSupported(DataFlavor flavor) {
return flavor.equals(allocationFlavor);
}
}*/
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.common;
import java.awt.Component;
import java.text.MessageFormat;
import java.util.Locale;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JList;
import org.rapla.entities.Named;
public class NamedListCellRenderer extends DefaultListCellRenderer {
private static final long serialVersionUID = 1L;
Locale locale;
MessageFormat format = null;
public NamedListCellRenderer(Locale locale) {
this.locale = locale;
}
public NamedListCellRenderer(Locale locale,String formatString) {
this(locale);
this.format = new MessageFormat(formatString);
}
public Component getListCellRendererComponent(JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus) {
if (value instanceof Named)
value = ((Named) value).getName(locale);
if (format != null)
value = format.format(new Object[] {value});
return super.getListCellRendererComponent(list,value,index,isSelected,cellHasFocus);
}
}
| Java |
package org.rapla.gui.internal.common;
import org.rapla.framework.TypedComponentRole;
import org.rapla.gui.toolkit.RaplaMenu;
import org.rapla.gui.toolkit.RaplaMenubar;
public interface InternMenus
{
public static final TypedComponentRole<RaplaMenubar> MENU_BAR = new TypedComponentRole<RaplaMenubar>("org.rapla.gui.MenuBar");
public static final TypedComponentRole<RaplaMenu> FILE_MENU_ROLE = new TypedComponentRole<RaplaMenu>("org.rapla.gui.SystemMenu");
public static final TypedComponentRole<RaplaMenu> EXTRA_MENU_ROLE = new TypedComponentRole<RaplaMenu>("org.rapla.gui.ExtraMenu");
public static final TypedComponentRole<RaplaMenu> VIEW_MENU_ROLE =new TypedComponentRole<RaplaMenu>("org.rapla.gui.ViewMenu");
public static final TypedComponentRole<RaplaMenu> EXPORT_MENU_ROLE = new TypedComponentRole<RaplaMenu>("org.rapla.gui.ExportMenu");
public static final TypedComponentRole<RaplaMenu> ADMIN_MENU_ROLE =new TypedComponentRole<RaplaMenu>("org.rapla.gui.AdminMenu");
public static final TypedComponentRole<RaplaMenu> EDIT_MENU_ROLE = new TypedComponentRole<RaplaMenu>("org.rapla.gui.EditMenu");
public static final TypedComponentRole<RaplaMenu> IMPORT_MENU_ROLE =new TypedComponentRole<RaplaMenu>("org.rapla.gui.ImportMenu");
public static final TypedComponentRole<RaplaMenu> NEW_MENU_ROLE =new TypedComponentRole<RaplaMenu>("org.rapla.gui.NewMenu");
public static final TypedComponentRole<RaplaMenu> CALENDAR_SETTINGS = new TypedComponentRole<RaplaMenu>("org.rapla.gui.CalendarSettings");
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.common;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.util.Date;
import java.util.List;
import org.rapla.facade.CalendarModel;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.RaplaAction;
import org.rapla.gui.toolkit.DisposingTool;
import org.rapla.gui.toolkit.RaplaFrame;
public class CalendarAction extends RaplaAction {
CalendarSelectionModel model;
List<?> objects;
Component parent;
Date start;
public CalendarAction(RaplaContext sm,Component parent,CalendarModel selectionModel)
{
super( sm);
this.model = (CalendarSelectionModel)selectionModel.clone();
this.parent = parent;
putValue(NAME,getString("calendar"));
putValue(SMALL_ICON,getIcon("icon.calendar"));
}
public void changeObjects(List<?> objects) {
this.objects = objects;
}
public void setStart(Date start) {
this.start = start;
}
public void actionPerformed(ActionEvent evt) {
try {
RaplaFrame frame = new RaplaFrame(getContext());
Dimension dimension = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
frame.setSize(new Dimension(
Math.min(dimension.width,800)
,Math.min(dimension.height-10,630)
)
);
if (start != null)
model.setSelectedDate(start);
if (objects != null && objects.size() > 0)
model.setSelectedObjects( objects );
if ( model.getViewId( ).equals("table")) {
model.setViewId("week");
}
model.setOption( CalendarModel.ONLY_MY_EVENTS, "false");
model.setAllocatableFilter( null);
model.setReservationFilter( null);
frame.setTitle("Rapla " + getString("calendar"));
MultiCalendarView cal = new MultiCalendarView(getContext(),model, false );
frame.setContentPane(cal.getComponent());
frame.addWindowListener(new DisposingTool(cal));
boolean packFrame = false;
frame.place( true, packFrame );
frame.setVisible(true);
cal.getSelectedCalendar().scrollToStart();
} catch (Exception ex) {
showException(ex, parent);
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.common;
import java.awt.Component;
import java.util.Calendar;
import java.util.Date;
import javax.swing.DefaultComboBoxModel;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JComboBox;
import javax.swing.JList;
import org.rapla.components.util.DateTools;
import org.rapla.components.xmlbundle.I18nBundle;
import org.rapla.entities.domain.Period;
import org.rapla.facade.ClientFacade;
import org.rapla.facade.PeriodModel;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.Disposable;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
public class PeriodChooser extends JComboBox implements Disposable
{
private static final long serialVersionUID = 1L;
Date selectedDate = null;
Period selectedPeriod = null;
public static int START_ONLY = 1;
public static int START_AND_END = 0;
public static int END_ONLY = -1;
int visiblePeriods;
I18nBundle i18n;
PeriodModel periodModel;
private boolean listenersEnabled = true;
private boolean isWeekOfPeriodVisible = true;
public PeriodChooser( RaplaContext context) throws RaplaException {
this(context,START_AND_END);
}
public PeriodChooser(RaplaContext context,int visiblePeriods) throws RaplaException {
// super(RaplaButton.SMALL);
this.visiblePeriods = visiblePeriods;
i18n = context.lookup(RaplaComponent.RAPLA_RESOURCES);
setPeriodModel( context.lookup(ClientFacade.class) .getPeriodModel());
}
@SuppressWarnings("unchecked")
public void setPeriodModel(PeriodModel model) {
this.periodModel = model;
if ( periodModel != null ) {
try {
listenersEnabled = false;
DefaultComboBoxModel aModel = new DefaultComboBoxModel(model.getAllPeriods());
this.setModel(aModel);
} finally {
listenersEnabled = true;
}
}
setRenderer(new PeriodListCellRenderer());
update();
}
public void dispose() {
listenersEnabled = false;
}
private String formatPeriod(Period period) {
if ( !isWeekOfPeriodVisible)
{
return period.getName();
}
int lastWeek = period.getWeeks();
int week = weekOf(period,selectedDate);
if (week != 1 && week >= lastWeek) {
return i18n.format(
"period.format.end"
,period.getName()
);
} else {
return i18n.format(
"period.format.week"
,String.valueOf(weekOf(period,selectedDate))
,period.getName()
);
}
}
public static int weekOf(Period period, Date date) {
Date start = period.getStart();
Calendar cal = Calendar.getInstance(DateTools.getTimeZone());
if (!period.contains(date) || start == null)
return -1;
long duration = date.getTime() - start.getTime();
long weeks = duration / (DateTools.MILLISECONDS_PER_WEEK);
// setTimeInMillis has protected access in JDK 1.3.1
cal.setTime(new Date(date.getTime() - weeks * DateTools.MILLISECONDS_PER_WEEK));
int week_of_year = cal.get(Calendar.WEEK_OF_YEAR);
cal.setTime(start);
return ((int)weeks) + 1
+ (((week_of_year) != cal.get(Calendar.WEEK_OF_YEAR))? 1 :0);
}
private String formatPeriodList(Period period) {
if (visiblePeriods == START_ONLY) {
return i18n.format(
"period.format.start"
,period.getName()
);
} else if (visiblePeriods == END_ONLY) {
return i18n.format(
"period.format.end"
,period.getName()
);
} else {
return period.getName();
}
}
public void setDate(Date date, Date endDate) {
try {
listenersEnabled = false;
if (date != selectedDate) // Compute period only on date change
{
selectedPeriod = getPeriod(date, endDate);
}
if ( selectedPeriod != null )
{
selectedDate = date;
setSelectedItem(selectedPeriod);
}
else
{
selectedDate = date;
setSelectedItem(null);
}
repaint();
revalidate();
} finally {
listenersEnabled = true;
}
}
public void setDate(Date date) {
setDate(date, null);
}
private String getSelectionText() {
Period period = selectedPeriod;
if ( period != null ) {
return formatPeriod(period);
} else {
return i18n.getString("period.not_set");
}
}
public void setSelectedPeriod(Period period) {
selectedPeriod = period; // EXCO
listenersEnabled = false;
setSelectedItem(period);
listenersEnabled = true;
if (visiblePeriods == END_ONLY) {
selectedDate = period.getEnd();
} else {
selectedDate = period.getStart();
}
}
public Period getPeriod() {
return selectedPeriod; // getPeriod(selectedDate);
}
private Period getPeriod(Date date, Date endDate) {
if (periodModel == null )
return null;
if ( visiblePeriods == END_ONLY) {
return periodModel.getNearestPeriodForEndDate(date);
} else {
return periodModel.getNearestPeriodForStartDate(date, endDate);
}
}
public Date getDate() {
return selectedDate;
}
private void update() {
setVisible(periodModel != null && periodModel.getSize() > 0);
setDate(getDate());
}
protected void fireActionEvent() {
if ( !listenersEnabled )
{
return ;
}
Period period = (Period) getSelectedItem();
selectedPeriod = period; // EXCO
if (period != null)
{
if (visiblePeriods == END_ONLY) {
selectedDate = period.getEnd();
} else {
selectedDate = period.getStart();
}
}
super.fireActionEvent();
}
class PeriodListCellRenderer extends DefaultListCellRenderer {
private static final long serialVersionUID = 1L;
public Component getListCellRendererComponent(
JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus)
{
if (index == -1) {
value = getSelectionText();
} else {
Period period = (Period) value;
value = formatPeriodList(period);
}
return super.getListCellRendererComponent(list,
value,
index,
isSelected,
cellHasFocus);
}
}
public boolean isWeekOfPeriodVisible()
{
return isWeekOfPeriodVisible;
}
public void setWeekOfPeriodVisible( boolean isWeekOfPeriodVisible )
{
this.isWeekOfPeriodVisible = isWeekOfPeriodVisible;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Gereon Fassbender, Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.print;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dialog;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.util.HashMap;
import java.util.Map;
import javax.swing.AbstractAction;
import javax.swing.Box;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import org.rapla.client.RaplaClientExtensionPoints;
import org.rapla.components.iolayer.ComponentPrinter;
import org.rapla.components.iolayer.IOInterface;
import org.rapla.components.xmlbundle.I18nBundle;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.Container;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaDefaultContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.SwingCalendarView;
import org.rapla.gui.SwingViewFactory;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.ErrorDialog;
import org.rapla.gui.toolkit.RaplaButton;
import org.rapla.plugin.abstractcalendar.MultiCalendarPrint;
public class CalendarPrintDialog extends DialogUI
{
private static final long serialVersionUID = 1L;
private JPanel titlePanel = new JPanel();
private JPanel southPanel = new JPanel();
private JLabel titleLabel = new JLabel();
private JLabel sizeLabel = new JLabel();
private JComboBox endDate;
private JTextField titleEdit = new JTextField();
private RaplaButton cancelbutton;
private RaplaButton formatbutton;
private RaplaButton printbutton;
private RaplaButton savebutton;
private JScrollPane scrollPane;
IOInterface printTool;
ExportServiceList exportServiceList;
// public static int[] sizes = new int[] {50,60,70,80,90,100,120,150,180,200};
public static double defaultBorder = 11.0; //11 mm defaultBorder
I18nBundle i18n;
Listener listener = new Listener();
PageFormat m_format;
protected SwingCalendarView currentView;
CalendarSelectionModel model;
Printable printable;
int curPage = 0;
JButton previousPage = new JButton("<");
JLabel pageLabel = new JLabel();
JButton nextPage = new JButton(">");
boolean updatePageCount = true;
int pageCount;
private JComponent page = new JComponent()
{
private static final long serialVersionUID = 1L;
public void paint(Graphics g)
{
try {
if ( updatePageCount )
{
pageCount = 0;
Graphics hidden = g.create();
while ( true )
{
int status = printable.print( hidden, m_format, pageCount);
boolean isNotExistant = status == Printable.NO_SUCH_PAGE;
if ( isNotExistant)
{
break;
}
pageCount++;
}
}
if ( curPage >= pageCount)
{
curPage = pageCount-1;
}
paintPaper( g, m_format );
printable.print( g, m_format, curPage);
pageLabel.setText(""+ (curPage +1) + "/" + pageCount);
boolean isLast = curPage >= pageCount -1;
nextPage.setEnabled( !isLast);
previousPage.setEnabled( curPage > 0);
savebutton.setEnabled(pageCount!=0);
} catch (PrinterException e) {
e.printStackTrace();
}
finally
{
updatePageCount = false;
}
}
protected void paintPaper(Graphics g, PageFormat format ) {
g.setColor(Color.white);
Rectangle rect = g.getClipBounds();
int paperHeight = (int)format.getHeight();
int paperWidth = (int)format.getWidth();
g.fillRect(rect.x, rect.y , Math.min(rect.width,Math.max(0,paperWidth-rect.x)), Math.min(rect.height, Math.max(0,paperHeight- rect.y)));
g.setColor(Color.black);
g.drawRect(1, 1 , paperWidth - 2, paperHeight - 2);
}
};
public static CalendarPrintDialog create(RaplaContext sm,Component owner,boolean modal,CalendarSelectionModel model,PageFormat format) throws RaplaException {
CalendarPrintDialog dlg;
Component topLevel = getOwnerWindow(owner);
if (topLevel instanceof Dialog)
dlg = new CalendarPrintDialog(sm,(Dialog)topLevel);
else
dlg = new CalendarPrintDialog(sm,(Frame)topLevel);
try {
dlg.init(modal,model,format);
} catch (Exception ex) {
throw new RaplaException( ex );
}
return dlg;
}
protected CalendarPrintDialog(RaplaContext context,Dialog owner) throws RaplaException {
super(context,owner);
init(context);
}
protected CalendarPrintDialog(RaplaContext context,Frame owner) throws RaplaException {
super(context,owner);
init(context);
}
private void init(RaplaContext context) throws RaplaException{
exportServiceList = new ExportServiceList( context);
}
private void init(boolean modal,CalendarSelectionModel model,PageFormat format) throws Exception {
super.init(modal,new JPanel(),new String[] {"print","format","print_to_file","cancel"});
this.model = model;
Map<String,SwingViewFactory> factoryMap = new HashMap<String, SwingViewFactory>();
for (SwingViewFactory fact: getContext().lookup(Container.class).lookupServicesFor(RaplaClientExtensionPoints.CALENDAR_VIEW_EXTENSION))
{
String id = fact.getViewId();
factoryMap.put( id , fact);
}
RaplaContext context = getContext();
printTool = context.lookup(IOInterface.class);
i18n = context.lookup(RaplaComponent.RAPLA_RESOURCES);
m_format = format;
if (m_format == null) {
m_format = createPageFormat();
m_format.setOrientation(m_format.getOrientation());
}
SwingViewFactory factory = factoryMap.get( model.getViewId());
RaplaDefaultContext contextWithPrintInfo = new RaplaDefaultContext(context);
contextWithPrintInfo.put(SwingViewFactory.PRINT_CONTEXT, new Boolean(true));
currentView = factory.createSwingView( contextWithPrintInfo, model, false);
if ( currentView instanceof Printable)
{
printable = (Printable)currentView;
}
else
{
Component comp = currentView.getComponent();
printable = new ComponentPrinter( comp, comp.getPreferredSize());
}
String title = model.getTitle();
content.setLayout(new BorderLayout());
titlePanel.add(titleLabel);
titlePanel.add(titleEdit);
new RaplaGUIComponent( context).addCopyPaste(titleEdit);
if ( currentView instanceof MultiCalendarPrint)
{
MultiCalendarPrint multiPrint = (MultiCalendarPrint) currentView;
sizeLabel.setText(multiPrint.getCalendarUnit() + ":");
String[] blockSizes = new String[52];
for (int i=0;i<blockSizes.length;i++)
{
blockSizes[i] = String.valueOf(i+1);
}
@SuppressWarnings("unchecked")
JComboBox jComboBox = new JComboBox(blockSizes);
endDate= jComboBox;
endDate.setEditable(true);
endDate.setPreferredSize( new Dimension(40, 30));
titlePanel.add(Box.createHorizontalStrut(10));
titlePanel.add(sizeLabel);
titlePanel.add(endDate);
titlePanel.add(Box.createHorizontalStrut(10));
endDate.addActionListener(listener);
}
titlePanel.add(previousPage);
titlePanel.add(nextPage);
titlePanel.add(pageLabel);
titleEdit.setColumns(30);
titleEdit.setText(title);
content.add(titlePanel, BorderLayout.NORTH);
scrollPane =new JScrollPane( page );
scrollPane.setPreferredSize(new Dimension(730,450));
content.add(scrollPane, BorderLayout.CENTER);
content.add(southPanel, BorderLayout.SOUTH);
southPanel.setMaximumSize( new Dimension(1,1));
southPanel.setMinimumSize( new Dimension(1,1));
southPanel.setPreferredSize( new Dimension(1,1));
southPanel.setLayout( null);
southPanel.add( currentView.getComponent());
scrollPane.getVerticalScrollBar().setUnitIncrement(10);
scrollPane.getHorizontalScrollBar().setUnitIncrement(10);
updateSizes( m_format);
printbutton = getButton(0);
printbutton.setAction(listener);
formatbutton = getButton(1);
formatbutton.setAction(listener);
savebutton = getButton(2);
savebutton.setAction(listener);
cancelbutton = getButton(3);
savebutton.setVisible(exportServiceList.getServices().length>0);
//swingCalendar.setPrintView(true);
currentView.update();
//sizeLabel.setText("Endedatum:");
titleLabel.setText(i18n.getString("weekview.print.title_textfield")+":");
setTitle(i18n.getString("weekview.print.dialog_title"));
printbutton.setIcon(i18n.getIcon("icon.print"));
savebutton.setText(i18n.getString("print_to_file"));
savebutton.setIcon(i18n.getIcon("icon.pdf"));
printbutton.setText(i18n.getString("print"));
formatbutton.setText(i18n.getString("weekview.print.format_button"));
cancelbutton.setText(i18n.getString("cancel"));
cancelbutton.setIcon(i18n.getIcon("icon.cancel"));
pageLabel.setText(""+1);
/*
if (getSession().getValue(LAST_SELECTED_SIZE) != null)
weekview.setSlotSize(((Integer)getSession().getValue(LAST_SELECTED_SIZE)).intValue());
*/
// int columnSize = model.getSize();
// sizeChooser.setSelectedItem(String.valueOf(columnSize));
titleEdit.addActionListener(listener);
titleEdit.addKeyListener(listener);
nextPage.addActionListener( listener);
previousPage.addActionListener( listener);
}
private void updateSizes( @SuppressWarnings("unused") PageFormat format)
{
//double paperHeight = format.getHeight();
//int height = (int)paperHeight + 100;
int height = 2000;
int width = 900;
updatePageCount = true;
page.setPreferredSize( new Dimension( width,height));
}
private PageFormat createPageFormat() {
PageFormat format= (PageFormat) printTool.defaultPage().clone();
format.setOrientation(PageFormat.LANDSCAPE);
Paper paper = format.getPaper();
paper.setImageableArea(
defaultBorder * IOInterface.MM_TO_INCH * 72
,defaultBorder * IOInterface.MM_TO_INCH * 72
,paper.getWidth() - 2 * defaultBorder * IOInterface.MM_TO_INCH * 72
,paper.getHeight() - 2 * defaultBorder * IOInterface.MM_TO_INCH * 72
);
format.setPaper(paper);
return format;
}
public void start() {
super.start();
}
private class Listener extends AbstractAction implements KeyListener {
private static final long serialVersionUID = 1L;
public void keyReleased(KeyEvent evt) {
try {
processTitleChange();
} catch (Exception ex) {
showException(ex);
}
}
protected void processTitleChange() throws RaplaException {
String oldTitle = model.getTitle();
String newTitle = titleEdit.getText();
model.setTitle(newTitle);
// only update view if title is set or removed not on every keystroke
if ((( oldTitle == null || oldTitle.length() == 0) && (newTitle != null && newTitle.length() > 0))
|| ((oldTitle != null && oldTitle.length() > 0 ) && ( newTitle == null || newTitle.length() ==0))
)
{
currentView.update(); // BJO performance issue
}
scrollPane.invalidate();
scrollPane.repaint();
}
public void keyTyped(KeyEvent evt) {
}
public void keyPressed(KeyEvent evt) {
}
public void actionPerformed(ActionEvent evt) {
try {
if (evt.getSource()==endDate) {
try {
Object selectedItem = endDate.getSelectedItem();
if ( selectedItem != null )
{
try
{
Integer units = Integer.valueOf(selectedItem.toString());
((MultiCalendarPrint)currentView).setUnits( units);
}
catch (NumberFormatException ex)
{
}
}
updatePageCount = true;
} catch (Exception ex) {
return;
}
currentView.update();
scrollPane.invalidate();
scrollPane.repaint();
}
if (evt.getSource()==titleEdit) {
processTitleChange();
}
if (evt.getSource()==formatbutton) {
m_format= printTool.showFormatDialog(m_format);
scrollPane.invalidate();
scrollPane.repaint();
updateSizes( m_format);
}
if (evt.getSource()==nextPage) {
curPage++;
scrollPane.repaint();
}
if (evt.getSource()==previousPage) {
curPage = Math.max(0,curPage -1 );
scrollPane.repaint();
}
if (evt.getSource()==printbutton) {
if (printTool.print(printable, m_format, true))
{
// We can't close or otherwise it won't work under windows
//close();
}
}
if (evt.getSource()==savebutton) {
boolean success = exportServiceList.export(printable, m_format, scrollPane);
Component topLevel = getParent();
if(success )
{
if (confirmPrint(topLevel))
{
close();
}
}
}
} catch (Exception ex) {
showException(ex);
}
}
}
protected boolean confirmPrint(Component topLevel) {
try {
DialogUI dlg = DialogUI.create(
getContext()
,topLevel
,true
,i18n.getString("print")
,i18n.getString("file_saved")
,new String[] { i18n.getString("ok")}
);
dlg.setIcon(i18n.getIcon("icon.pdf"));
dlg.setDefault(0);
dlg.start();
return (dlg.getSelectedIndex() == 0);
} catch (RaplaException e) {
return true;
}
}
public void showException(Exception ex) {
ErrorDialog dialog;
try {
dialog = new ErrorDialog(getContext());
dialog.showExceptionDialog(ex,this);
} catch (RaplaException e) {
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.print;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.util.Collection;
import java.util.HashMap;
import javax.swing.BorderFactory;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.ListSelectionModel;
import org.rapla.components.iolayer.IOInterface;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.RaplaException;
import org.rapla.framework.StartupEnvironment;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.common.NamedListCellRenderer;
import org.rapla.gui.toolkit.DialogUI;
public class ExportServiceList extends RaplaGUIComponent {
HashMap<Object,ExportService> exporters = new HashMap<Object,ExportService>();
/**
* @param sm
* @throws RaplaException
*/
public ExportServiceList(RaplaContext sm) throws RaplaException {
super(sm);
IOInterface printInterface = getService( IOInterface.class);
boolean applet =(getService(StartupEnvironment.class)).getStartupMode() == StartupEnvironment.APPLET;
if (printInterface.supportsPostscriptExport() && !applet) {
PSExportService exportService = new PSExportService(getContext());
addService("psexport",exportService);
}
if (!applet) {
PDFExportService exportService = new PDFExportService(getContext());
addService("pdf",exportService);
}
}
public boolean export(Printable printable,PageFormat pageFormat,Component parentComponent) throws Exception
{
Collection<ExportService> services = exporters.values();
Object[] serviceArray = services.toArray();
@SuppressWarnings("unchecked")
JList list = new JList(serviceArray);
JPanel panel = new JPanel();
panel.setLayout(new BorderLayout());
panel.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
panel.add(new JLabel(getString("weekview.print.choose_export")),BorderLayout.NORTH);
panel.add(list,BorderLayout.CENTER);
setRenderer(list);
list.setSelectedIndex(0);
list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
DialogUI dlg = DialogUI.create(getContext(),parentComponent,true,panel,
new String[] {
getString("export")
,getString("cancel")
});
dlg.setTitle(getString("weekview.print.choose_export"));
dlg.getButton(0).setIcon(getIcon("icon.save"));
dlg.getButton(1).setIcon(getIcon("icon.cancel"));
dlg.start();
if (dlg.getSelectedIndex() != 0 || list.getSelectedIndex() == -1)
return false;
ExportService selectedService = (ExportService)serviceArray[list.getSelectedIndex()];
boolean result = selectedService.export(printable,pageFormat, parentComponent);
return result;
}
@SuppressWarnings("unchecked")
private void setRenderer(JList list) {
list.setCellRenderer(new NamedListCellRenderer(getI18n().getLocale()));
}
public void addService(Object policy,ExportService exportService) {
exporters.put(policy, exportService);
}
public void removeService(Object policy) {
exporters.remove(policy);
}
public ExportService select(Object policy) throws RaplaContextException {
ExportService result = exporters.get(policy);
if (result == null)
throw new RaplaContextException("Export Service not found for key " + policy);
return result;
}
public boolean isSelectable(Object policy) {
return exporters.get(policy) != null;
}
public ExportService[] getServices() {
return exporters.values().toArray(new ExportService[0]);
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.print;
import java.awt.Component;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.util.Locale;
import org.rapla.components.iolayer.IOInterface;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.RaplaGUIComponent;
public class PSExportService extends RaplaGUIComponent implements ExportService {
public final static String EXPORT_DIR = PSExportService.class.getName() + ".dir";
IOInterface printInterface;
public PSExportService(RaplaContext sm){
super(sm);
printInterface = getService(IOInterface.class);
}
public boolean export(Printable printable,PageFormat pageFormat,Component parentComponent) throws Exception
{
String dir = (String) getSessionMap().get(EXPORT_DIR);
boolean isPDF = false;
String file = printInterface.saveAsFileShowDialog
(
dir
,printable
,pageFormat
,false
,parentComponent
,isPDF
);
if (file != null)
{
getSessionMap().put(EXPORT_DIR,file);
return true;
}
else
{
return false;
}
}
public String getName(Locale locale) {
return getI18n().getString("weekview.print.postscript");
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.print;
import java.awt.Component;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
public interface ExportService extends org.rapla.entities.Named {
boolean export(Printable printable,PageFormat pageFormat,Component parentComponent) throws Exception;
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.print;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.print.PageFormat;
import javax.swing.SwingUtilities;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.RaplaAction;
public class PrintAction extends RaplaAction {
CalendarSelectionModel model;
PageFormat m_pageFormat;
public PrintAction(RaplaContext sm) {
super( sm);
setEnabled(false);
putValue(NAME,getString("print"));
putValue(SMALL_ICON,getIcon("icon.print"));
}
public void setModel(CalendarSelectionModel settings) {
this.model = settings;
setEnabled(settings != null);
}
public void setPageFormat(PageFormat pageFormat) {
m_pageFormat = pageFormat;
}
public void actionPerformed(ActionEvent evt) {
Component parent = getMainComponent();
try {
boolean modal = true;
final CalendarPrintDialog dialog = CalendarPrintDialog.create(getContext(),parent,modal, model, m_pageFormat);
final Dimension dimension = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
dialog.setSize(new Dimension(
Math.min(dimension.width,900)
,Math.min(dimension.height-10,700)
)
);
SwingUtilities.invokeLater( new Runnable() {
public void run()
{
dialog.setSize(new Dimension(
Math.min(dimension.width,900)
,Math.min(dimension.height-11,699)
)
);
}
}
);
dialog.startNoPack();
} catch (Exception ex) {
showException(ex, parent);
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.print;
import java.awt.Component;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.util.Locale;
import org.rapla.components.iolayer.IOInterface;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.RaplaGUIComponent;
public class PDFExportService extends RaplaGUIComponent implements ExportService {
public final static String EXPORT_DIR = PDFExportService.class.getName() + ".dir";
IOInterface printInterface;
public PDFExportService(RaplaContext sm) {
super(sm);
printInterface = getService(IOInterface.class);
}
public boolean export(Printable printable,PageFormat pageFormat,Component parentComponent) throws Exception
{
String dir = (String) getSessionMap().get(EXPORT_DIR);
boolean isPDF = true;
String file = printInterface.saveAsFileShowDialog
(
dir
,printable
,pageFormat
,false
,parentComponent
, isPDF
);
if (file != null)
{
getSessionMap().put(EXPORT_DIR,file);
return true;
}
return false;
}
public String getName(Locale locale) {
return "PDF";
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import javax.swing.event.ChangeListener;
import org.rapla.gui.toolkit.RaplaWidget;
/** Base class for most rapla edit fields. Provides some mapping
functionality such as reflection invocation of getters/setters.
A fieldName "username" will result in a getUsername() and setUsername()
method.
*/
public interface EditField extends RaplaWidget
{
public String getFieldName();
/** registers new ChangeListener for this component.
* An ChangeEvent will be fired to every registered ChangeListener
* when the component info changes.
* @see javax.swing.event.ChangeListener
* @see javax.swing.event.ChangeEvent
*/
public void addChangeListener(ChangeListener listener);
/** removes a listener from this component.*/
public void removeChangeListener(ChangeListener listener);
}
| Java |
package org.rapla;
import java.util.Arrays;
/** Object that encapsulates the login information.
* For admin users it is possible to connect as an other user.
*/
public class ConnectInfo {
String username;
char[] password;
String connectAs;
public ConnectInfo(String username, char[] password, String connectAs) {
this.username = username;
this.password = password;
this.connectAs = connectAs;
}
public ConnectInfo(String username, char[] password) {
this( username, password, null);
}
public String getUsername() {
return username;
}
public char[] getPassword() {
return password;
}
public String getConnectAs() {
return connectAs;
}
@Override
public String toString() {
return "ReconnectInfo [username=" + username + ", password=" + Arrays.toString(password) + ", connectAs=" + connectAs + "]";
}
}
| Java |
package org.rapla.server;
import javax.servlet.http.HttpServletRequest;
import org.rapla.entities.User;
import org.rapla.framework.Configuration;
import org.rapla.framework.Container;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.RaplaException;
import org.rapla.servletpages.RaplaPageGenerator;
public interface ServerServiceContainer extends Container
{
<T> void addRemoteMethodFactory( Class<T> service, Class<? extends RemoteMethodFactory<T>> factory);
<T> void addRemoteMethodFactory( Class<T> service, Class<? extends RemoteMethodFactory<T>> factory, Configuration config);
/**
* You can add arbitrary serlvet pages to your rapla webapp.
*
* Example that adds a page with the name "my-page-name" and the class
* "org.rapla.plugin.myplugin.MyPageGenerator". You can call this page with <code>rapla?page=my-page-name</code>
* <p/>
* In the provideService Method of your PluginDescriptor do the following
<pre>
container.addContainerProvidedComponent( RaplaExtensionPoints.SERVLET_PAGE_EXTENSION, "org.rapla.plugin.myplugin.MyPageGenerator", "my-page-name", config);
</pre>
*@see org.rapla.servletpages.RaplaPageGenerator
*/
<T extends RaplaPageGenerator> void addWebpage(String pagename, Class<T> pageClass);
<T extends RaplaPageGenerator> void addWebpage(String pagename, Class<T> pageClass, Configuration config);
/** @return null when the server doesn't have the webpage
* @throws RaplaContextException */
RaplaPageGenerator getWebpage(String page);
public User getUser(HttpServletRequest request) throws RaplaException;
<T> T createWebservice(Class<T> role,HttpServletRequest request ) throws RaplaException;
boolean hasWebservice(String interfaceName);
}
| Java |
package org.rapla.server;
import java.util.Collection;
import org.rapla.entities.User;
import org.rapla.framework.RaplaException;
import org.rapla.framework.TypedComponentRole;
public interface RaplaKeyStorage {
public String getRootKeyBase64();
public LoginInfo getSecrets(User user, TypedComponentRole<String> tagName) throws RaplaException;
public void storeLoginInfo(User user,TypedComponentRole<String> tagName,String login,String secret) throws RaplaException;
public void removeLoginInfo(User user, TypedComponentRole<String> tagName) throws RaplaException;
public void storeAPIKey(User user,String clientId,String apiKey) throws RaplaException;
public Collection<String> getAPIKeys(User user) throws RaplaException;
public void removeAPIKey(User user,String key) throws RaplaException;
public class LoginInfo
{
public String login;
public String secret;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2013 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.server;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.rapla.ConnectInfo;
import org.rapla.RaplaMainContainer;
import org.rapla.RaplaStartupEnvironment;
import org.rapla.client.ClientService;
import org.rapla.client.ClientServiceContainer;
import org.rapla.client.RaplaClientListenerAdapter;
import org.rapla.components.util.IOUtil;
import org.rapla.components.xmlbundle.I18nBundle;
import org.rapla.entities.User;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.Container;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.RaplaDefaultContext;
import org.rapla.framework.RaplaException;
import org.rapla.framework.ServiceListCreator;
import org.rapla.framework.StartupEnvironment;
import org.rapla.framework.internal.ContainerImpl;
import org.rapla.framework.internal.RaplaJDKLoggingAdapter;
import org.rapla.framework.logger.Logger;
import org.rapla.server.internal.ServerServiceImpl;
import org.rapla.server.internal.ShutdownService;
import org.rapla.servletpages.RaplaPageGenerator;
import org.rapla.servletpages.ServletRequestPreprocessor;
import org.rapla.storage.ImportExportManager;
import org.rapla.storage.StorageOperator;
import org.rapla.storage.dbrm.RemoteMethodStub;
import org.rapla.storage.dbrm.WrongRaplaVersionException;
public class MainServlet extends HttpServlet {
private static final String RAPLA_RPC_PATH = "/rapla/rpc/";
private static final long serialVersionUID = 1L;
/** The default config filename is raplaserver.xconf*/
private ContainerImpl raplaContainer;
public final static String DEFAULT_CONFIG_NAME = "raplaserver.xconf";
private Logger logger = null;
private String startupMode =null;
private String startupUser = null;
private Integer port;
private String contextPath;
private String env_rapladatasource;
private String env_raplafile;
private Object env_rapladb;
private Object env_raplamail;
private Boolean env_development;
private String downloadUrl;
private String serverVersion;
private ServerServiceImpl server;
private Runnable shutdownCommand;
private Collection<ServletRequestPreprocessor> processors;
private ReadWriteLock restartLock = new ReentrantReadWriteLock();
// the following variables are only for non server startup
private Semaphore guiMutex = new Semaphore(1);
private ConnectInfo reconnect;
private URL getConfigFile(String entryName, String defaultName) throws ServletException,IOException {
String configName = getServletConfig().getInitParameter(entryName);
if (configName == null)
configName = defaultName;
if (configName == null)
throw new ServletException("Must specify " + entryName + " entry in web.xml !");
String realPath = getServletConfig().getServletContext().getRealPath("/WEB-INF/" + configName);
if (realPath != null)
{
File configFile = new File(realPath);
if (configFile.exists()) {
URL configURL = configFile.toURI().toURL();
return configURL;
}
}
URL configURL = getClass().getResource("/raplaserver.xconf");
if ( configURL == null)
{
String message = "ERROR: Config file not found " + configName;
throw new ServletException(message);
}
else
{
return configURL;
}
}
/**
* Initializes Servlet and creates a <code>RaplaMainContainer</code> instance
*
* @exception ServletException if an error occurs
*/
synchronized public void init()
throws ServletException
{
getLogger().info("Init RaplaServlet");
Collection<String> instanceCounter = null;
String selectedContextPath = null;
Context env;
try
{
Context initContext = new InitialContext();
Context envContext = (Context)initContext.lookup("java:comp");
env = (Context)envContext.lookup("env");
} catch (Exception e) {
env = null;
getLogger().warn("No JNDI Enivronment found under java:comp or java:/comp");
}
if ( env != null)
{
env_rapladatasource = lookupEnvString(env, "rapladatasource", true);
env_raplafile = lookupEnvString(env,"raplafile", true);
env_rapladb = lookupResource(env, "jdbc/rapladb", true);
getLogger().info("Passed JNDI Environment rapladatasource=" + env_rapladatasource + " env_rapladb="+env_rapladb + " env_raplafile="+ env_raplafile);
if ( env_rapladatasource == null || env_rapladatasource.trim().length() == 0 || env_rapladatasource.startsWith( "${"))
{
if ( env_rapladb != null)
{
env_rapladatasource = "rapladb";
}
else if ( env_raplafile != null)
{
env_rapladatasource = "raplafile";
}
else
{
getLogger().warn("Neither file nor database setup configured.");
}
}
env_raplamail = lookupResource(env, "mail/Session", false);
startupMode = lookupEnvString(env,"rapla_startup_mode", false);
env_development = (Boolean) lookupEnvVariable(env, "rapla_development", false);
@SuppressWarnings("unchecked")
Collection<String> instanceCounterLookup = (Collection<String>) lookup(env,"rapla_instance_counter", false);
instanceCounter = instanceCounterLookup;
selectedContextPath = lookupEnvString(env,"rapla_startup_context", false);
startupUser = lookupEnvString( env, "rapla_startup_user", false);
shutdownCommand = (Runnable) lookup(env,"rapla_shutdown_command", false);
port = (Integer) lookup(env,"rapla_startup_port", false);
downloadUrl = (String) lookup(env,"rapla_download_url", false);
}
if ( startupMode == null)
{
startupMode = "server";
}
contextPath = getServletContext().getContextPath();
if ( !contextPath.startsWith("/"))
{
contextPath = "/" + contextPath;
}
// don't startup server if contextPath is not selected
if ( selectedContextPath != null)
{
if( !contextPath.equals(selectedContextPath))
return;
}
else if ( instanceCounter != null)
{
instanceCounter.add( contextPath);
if ( instanceCounter.size() > 1)
{
String msg = ("Ignoring webapp ["+ contextPath +"]. Multiple context found in jetty container " + instanceCounter + " You can specify one via -Dorg.rapla.context=REPLACE_WITH_CONTEXT");
getLogger().error(msg);
return;
}
}
startServer(startupMode);
if ( startupMode.equals("standalone") || startupMode.equals("client"))
{
try {
guiMutex.acquire();
} catch (InterruptedException e) {
}
try
{
startGUI(startupMode);
}
catch (Exception ex)
{
exit();
throw new ServletException(ex);
}
}
}
private Object lookupResource(Context env, String lookupname, boolean log) {
String newLookupname = getServletContext().getInitParameter(lookupname);
if (newLookupname != null && newLookupname.length() > 0)
{
lookupname = newLookupname;
}
Object result = lookup(env,lookupname, log);
return result;
}
private String lookupEnvString(Context env, String lookupname, boolean log) {
Object result = lookupEnvVariable(env, lookupname, log);
return (String) result;
}
private Object lookupEnvVariable(Context env, String lookupname, boolean log) {
String newEnvname = getServletContext().getInitParameter(lookupname);
if ( newEnvname != null)
{
getLogger().info("Using contextparam for " + lookupname + ": " + newEnvname);
}
if (newEnvname != null && newEnvname.length() > 0 )
{
return newEnvname;
}
else
{
Object result = lookup(env,lookupname, log);
return result;
}
}
private Object lookup(Context env, String string, boolean warn) {
try {
Object result = env.lookup( string);
if ( result == null && warn)
{
getLogger().warn("JNDI Entry "+ string + " not found");
}
return result;
} catch (Exception e) {
if ( warn )
{
getLogger().warn("JNDI Entry "+ string + " not found");
}
return null;
}
}
private void startGUI(final String startupMode) throws ServletException {
ConnectInfo connectInfo = null;
if (startupMode.equals("standalone"))
{
try
{
String username = startupUser;
if ( username == null )
{
username = getFirstAdmin();
}
if ( username != null)
{
connectInfo = new ConnectInfo(username, "".toCharArray());
}
}
catch (RaplaException ex)
{
getLogger().error(ex.getMessage(),ex);
}
}
startGUI( startupMode, connectInfo);
if ( startupMode.equals("standalone") || startupMode.equals("client"))
{
try {
guiMutex.acquire();
while ( reconnect != null )
{
raplaContainer.dispose();
try {
if ( startupMode.equals("client"))
{
initContainer(startupMode);
}
else if ( startupMode.equals("standalone"))
{
startServer("standalone");
}
if ( startupMode.equals("standalone") && reconnect.getUsername() == null)
{
String username = getFirstAdmin();
if ( username != null)
{
reconnect= new ConnectInfo(username, "".toCharArray());
}
}
startGUI(startupMode, reconnect);
guiMutex.acquire();
} catch (Exception ex) {
getLogger().error("Error restarting client",ex);
exit();
return;
}
}
} catch (InterruptedException e) {
}
}
}
protected String getFirstAdmin() throws RaplaContextException, RaplaException {
String username = null;
StorageOperator operator = server.getContext().lookup(StorageOperator.class);
for (User u:operator.getUsers())
{
if ( u.isAdmin())
{
username = u.getUsername();
break;
}
}
return username;
}
public void startGUI( final String startupMode, ConnectInfo connectInfo) throws ServletException {
try
{
if ( startupMode.equals("standalone") || startupMode.equals("client"))
{
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
try
{
Thread.currentThread().setContextClassLoader( ClassLoader.getSystemClassLoader());
ClientServiceContainer clientContainer = raplaContainer.getContext().lookup(ClientServiceContainer.class );
ClientService client = clientContainer.getContext().lookup( ClientService.class);
client.addRaplaClientListener(new RaplaClientListenerAdapter() {
public void clientClosed(ConnectInfo reconnect) {
MainServlet.this.reconnect = reconnect;
if ( reconnect != null) {
guiMutex.release();
} else {
exit();
}
}
public void clientAborted()
{
exit();
}
});
clientContainer.start(connectInfo);
}
finally
{
Thread.currentThread().setContextClassLoader( contextClassLoader);
}
}
else if (!startupMode.equals("server"))
{
exit();
}
}
catch( Exception e )
{
getLogger().error("Could not start server", e);
if ( raplaContainer != null)
{
raplaContainer.dispose();
}
throw new ServletException( "Error during initialization see logs for details: " + e.getMessage(), e );
}
// log("Rapla Servlet started");
}
protected void startServer(final String startupMode)
throws ServletException {
try
{
initContainer(startupMode);
if ( startupMode.equals("import"))
{
ImportExportManager manager = raplaContainer.getContext().lookup(ImportExportManager.class);
manager.doImport();
exit();
}
else if (startupMode.equals("export"))
{
ImportExportManager manager = raplaContainer.getContext().lookup(ImportExportManager.class);
manager.doExport();
exit();
}
else if ( startupMode.equals("server") || startupMode.equals("standalone") )
{
String hint = serverContainerHint != null ? serverContainerHint :"*";
// Start the server via lookup
// We start the standalone server before the client to prevent jndi lookup failures
server = (ServerServiceImpl) raplaContainer.lookup( ServerServiceContainer.class, hint);
processors = server.lookupServicesFor(RaplaServerExtensionPoints.SERVLET_REQUEST_RESPONSE_PREPROCESSING_POINT);
final Logger logger = getLogger();
logger.info("Rapla server started");
if ( startupMode.equals("server"))
{
// if
setShutdownService(startupMode);
}
else
{
raplaContainer.addContainerProvidedComponentInstance(RemoteMethodStub.class, server);
}
}
}
catch( Exception e )
{
getLogger().error(e.getMessage(), e);
String message = "Error during initialization see logs for details: " + e.getMessage();
if ( raplaContainer != null)
{
raplaContainer.dispose();
}
if ( shutdownCommand != null)
{
shutdownCommand.run();
}
throw new ServletException( message,e);
}
}
protected void setShutdownService(final String startupMode) {
server.setShutdownService( new ShutdownService() {
public void shutdown(final boolean restart) {
Lock writeLock;
try
{
try
{
RaplaComponent.unlock( restartLock.readLock());
}
catch (IllegalMonitorStateException ex)
{
getLogger().error("Error unlocking read for restart " + ex.getMessage());
}
writeLock = RaplaComponent.lock( restartLock.writeLock(), 60);
}
catch (RaplaException ex)
{
getLogger().error("Can't restart server " + ex.getMessage());
return;
}
try
{
//acquired = requestCount.tryAcquire(maxRequests -1,10, TimeUnit.SECONDS);
logger.info( "Stopping Server");
stopServer();
if ( restart)
{
try {
logger.info( "Restarting Server");
MainServlet.this.startServer(startupMode);
} catch (Exception e) {
logger.error( "Error while restarting Server", e );
}
}
}
finally
{
RaplaComponent.unlock(writeLock);
}
}
});
}
protected void initContainer(String startupMode) throws ServletException, IOException,
MalformedURLException, Exception, RaplaContextException {
URL configURL = getConfigFile("config-file",DEFAULT_CONFIG_NAME);
//URL logConfigURL = getConfigFile("log-config-file","raplaserver.xlog").toURI().toURL();
RaplaStartupEnvironment env = new RaplaStartupEnvironment();
env.setStartupMode( StartupEnvironment.CONSOLE);
env.setConfigURL( configURL );
if ( startupMode.equals( "client"))
{
if ( port != null)
{
String url = downloadUrl;
if ( url == null)
{
url = "http://localhost:" + port+ contextPath;
if (! url.endsWith("/"))
{
url += "/";
}
}
env.setDownloadURL( new URL(url));
}
}
// env.setContextRootURL( contextRootURL );
//env.setLogConfigURL( logConfigURL );
RaplaDefaultContext context = new RaplaDefaultContext();
if ( env_rapladatasource != null)
{
context.put(RaplaMainContainer.ENV_RAPLADATASOURCE, env_rapladatasource);
}
if ( env_raplafile != null)
{
context.put(RaplaMainContainer.ENV_RAPLAFILE, env_raplafile);
}
if ( env_rapladb != null)
{
context.put(RaplaMainContainer.ENV_RAPLADB, env_rapladb);
}
if ( env_raplamail != null)
{
context.put(RaplaMainContainer.ENV_RAPLAMAIL, env_raplamail);
getLogger().info("Configured mail service via JNDI");
}
if ( env_development != null && env_development)
{
context.put(RaplaMainContainer.ENV_DEVELOPMENT, Boolean.TRUE);
}
raplaContainer = new RaplaMainContainer( env, context );
logger = raplaContainer.getContext().lookup(Logger.class);
if ( env_development != null && env_development)
{
addDevelopmentWarFolders();
}
serverVersion = raplaContainer.getContext().lookup(RaplaComponent.RAPLA_RESOURCES).getString("rapla.version");
}
// add the war folders of the plugins to jetty resource handler so that the files inside the war
// folders can be served from within jetty, even when they are not located in the same folder.
// The method will search the class path for plugin classes and then add the look for a war folder entry in the file hierarchy
// so a plugin allways needs a plugin class for this to work
@SuppressWarnings("unchecked")
private void addDevelopmentWarFolders()
{
Thread currentThread = Thread.currentThread();
ClassLoader classLoader = currentThread.getContextClassLoader();
ClassLoader parent = null;
try
{
Collection<File> webappFolders = ServiceListCreator.findPluginWebappfolders(logger);
if ( webappFolders.size() < 1)
{
return;
}
parent = classLoader.getParent();
if ( parent != null)
{
currentThread.setContextClassLoader( parent);
}
// first we need to access the necessary classes via reflection (are all loaded, because webapplication is already initialized)
final Class WebAppClassLoaderC = Class.forName("org.eclipse.jetty.webapp.WebAppClassLoader",false, parent);
final Class WebAppContextC = Class.forName("org.eclipse.jetty.webapp.WebAppContext",false, parent);
final Class ResourceCollectionC = Class.forName("org.eclipse.jetty.util.resource.ResourceCollection",false, parent);
final Class FileResourceC = Class.forName("org.eclipse.jetty.util.resource.FileResource",false, parent);
final Object webappContext = WebAppClassLoaderC.getMethod("getContext").invoke(classLoader);
if (webappContext == null)
{
return;
}
final Object baseResource = WebAppContextC.getMethod("getBaseResource").invoke( webappContext);
if ( baseResource != null && ResourceCollectionC.isInstance( baseResource) )
{
//Resource[] resources = ((ResourceCollection) baseResource).getResources();
final Object[] resources = (Object[])ResourceCollectionC.getMethod("getResources").invoke( baseResource);
Set list = new HashSet( Arrays.asList( resources));
for (File folder:webappFolders)
{
Object fileResource = FileResourceC.getConstructor( URL.class).newInstance( folder.toURI().toURL());
if ( !list.contains( fileResource))
{
list.add( fileResource);
getLogger().info("Adding " + fileResource + " to webapp folder");
}
}
Object[] array = list.toArray( resources);
//((ResourceCollection) baseResource).setResources( array);
ResourceCollectionC.getMethod("setResources", resources.getClass()).invoke( baseResource, new Object[] {array});
//ResourceCollectionC.getMethod(", parameterTypes)
}
}
catch (ClassNotFoundException ex)
{
getLogger().info("Development mode not in jetty so war finder will be disabled");
}
catch (Exception ex)
{
getLogger().error(ex.getMessage(), ex);
}
finally
{
if ( parent != null)
{
currentThread.setContextClassLoader( classLoader);
}
}
}
private void exit() {
MainServlet.this.reconnect = null;
guiMutex.release();
if ( shutdownCommand != null)
{
shutdownCommand.run();
}
}
public void service( HttpServletRequest request, HttpServletResponse response ) throws IOException, ServletException
{
RaplaPageGenerator servletPage;
Lock readLock = null;
try
{
try
{
readLock = RaplaComponent.lock( restartLock.readLock(), 25);
RaplaContext context = server.getContext();
for (ServletRequestPreprocessor preprocessor: processors)
{
final HttpServletRequest newRequest = preprocessor.handleRequest(context, getServletContext(), request, response);
if (newRequest != null)
request = newRequest;
if (response.isCommitted())
return;
}
}
catch (RaplaException e)
{
java.io.PrintWriter out = null;
try
{
response.setStatus( 500 );
out = response.getWriter();
out.println(IOUtil.getStackTraceAsString( e));
}
catch (Exception ex)
{
getLogger().error("Error writing exception back to client " + e.getMessage());
}
finally
{
if ( out != null)
{
out.close();
}
}
return;
}
String page = request.getParameter("page");
String requestURI =request.getRequestURI();
if ( page == null)
{
String raplaPrefix = "rapla/";
String contextPath = request.getContextPath();
String toParse;
if (requestURI.startsWith( contextPath))
{
toParse = requestURI.substring( contextPath.length());
}
else
{
toParse = requestURI;
}
int pageContextIndex = toParse.lastIndexOf(raplaPrefix);
if ( pageContextIndex>= 0)
{
page = toParse.substring( pageContextIndex + raplaPrefix.length());
int firstSeparator = page.indexOf('/');
if ( firstSeparator>1)
{
page = page.substring(0,firstSeparator );
}
}
}
//String servletPath = request.getServletPath();
if ( requestURI.indexOf(RAPLA_RPC_PATH) >= 0) {
handleOldRPCCall( request, response );
return;
}
// if ( requestURI.indexOf(RAPLA_JSON_PATH)>= 0) {
// handleJSONCall( request, response, requestURI );
// return;
// }
if ( page == null || page.trim().length() == 0) {
page = "index";
}
servletPage = server.getWebpage( page);
if ( servletPage == null)
{
response.setStatus( 404 );
java.io.PrintWriter out = null;
try
{
out = response.getWriter();
String message = "404: Page " + page + " not found in Rapla context";
out.print(message);
getLogger().getChildLogger("server.html.404").warn( message);
} finally
{
if ( out != null)
{
out.close();
}
}
return;
}
ServletContext servletContext = getServletContext();
servletPage.generatePage( servletContext, request, response);
}
finally
{
try
{
RaplaComponent.unlock( readLock );
}
catch (IllegalMonitorStateException ex)
{
// Released by the restarter
}
try
{
ServletOutputStream outputStream = response.getOutputStream();
outputStream.close();
}
catch (Exception ex)
{
}
}
}
/** serverContainerHint is useful when you have multiple server configurations in one config file e.g. in a test environment*/
public static String serverContainerHint = null;
private void stopServer() {
if ( raplaContainer == null)
{
return;
}
try {
raplaContainer.dispose();
} catch (Exception ex) {
String message = "Error while stopping server ";
getLogger().error(message + ex.getMessage());
}
}
/**
* Disposes of container manager and container instance.
*/
public void destroy()
{
stopServer();
}
public RaplaContext getContext()
{
return raplaContainer.getContext();
}
public Container getContainer()
{
return raplaContainer;
}
public void doImport() throws RaplaException {
ImportExportManager manager = raplaContainer.getContext().lookup(ImportExportManager.class);
manager.doImport();
}
public void doExport() throws RaplaException {
ImportExportManager manager = raplaContainer.getContext().lookup(ImportExportManager.class);
manager.doExport();
}
public Logger getLogger()
{
if ( logger == null)
{
return new RaplaJDKLoggingAdapter().get();
}
return logger;
}
// only for old rapla versions, will be removed in 2.0
private void handleOldRPCCall( HttpServletRequest request, HttpServletResponse response ) throws IOException
{
String clientVersion = request.getParameter("v");
if ( clientVersion != null )
{
String message = getVersionErrorText(request, clientVersion);
response.addHeader("X-Error-Classname", WrongRaplaVersionException.class.getName());
response.addHeader("X-Error-Stacktrace", message );
response.setStatus( 500);
}
else
{
//if ( !serverVersion.equals( clientVersion ) )
String message = getVersionErrorText(request, "");
response.addHeader("X-Error-Stacktrace", message );
RaplaException e1= new RaplaException( message );
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
ObjectOutputStream exout = new ObjectOutputStream( outStream);
exout.writeObject( e1);
exout.flush();
exout.close();
byte[] out = outStream.toByteArray();
ServletOutputStream outputStream = null;
try
{
outputStream = response.getOutputStream();
outputStream.write( out );
}
catch (Exception ex)
{
getLogger().error( " Error writing exception back to client " + ex.getMessage());
}
finally
{
if (outputStream != null)
{
outputStream.close();
}
}
response.setStatus( 500);
}
}
// only for old rapla versions, will be removed in 2.0
private String getVersionErrorText(HttpServletRequest request,String clientVersion)
{
String requestUrl = request.getRequestURL().toString();
int indexOf = requestUrl.indexOf( "rpc/");
if (indexOf>=0 )
{
requestUrl = requestUrl.substring( 0, indexOf) ;
}
String message;
try {
I18nBundle i18n = getContext().lookup(RaplaComponent.RAPLA_RESOURCES);
message = i18n.format("error.wrong_rapla_version", clientVersion, serverVersion, requestUrl);
} catch (Exception e) {
message = "Update client from " + clientVersion + " to " + serverVersion + " on " + requestUrl + ". Click on the webstart or applet to update.";
}
return message;
}
// private void handleRPCCall( HttpServletRequest request, HttpServletResponse response, String requestURI )
// {
// boolean dispatcherExceptionThrown = false;
// try
// {
// handleLogin(request, response, requestURI);
// final Map<String,String[]> originalMap = request.getParameterMap();
// final Map<String,String> parameterMap = makeSinglesAndRemoveVersion(originalMap);
// final ServerServiceContainer serverContainer = getServer();
// RemoteServiceDispatcher serviceDispater=serverContainer.getContext().lookup( RemoteServiceDispatcher.class);
// byte[] out;
// try
// {
// out =null;
// //out = serviceDispater.dispatch(remoteSession, methodName, parameterMap);
// }
// catch (Exception ex)
// {
// dispatcherExceptionThrown = true;
// throw ex;
// }
// //String test = new String( out);
// response.setContentType( "text/html; charset=utf-8");
// try
// {
// response.getOutputStream().write( out);
// response.flushBuffer();
// response.getOutputStream().close();
// }
// catch (Exception ex)
// {
// getLogger().error( " Error writing exception back to client " + ex.getMessage());
// }
// }
// catch (Exception e)
// {
// if ( !dispatcherExceptionThrown)
// {
// getLogger().error(e.getMessage(), e);
// }
// try
// {
// String message = e.getMessage();
// String name = e.getClass().getName();
// if ( message == null )
// {
// message = name;
// }
// response.addHeader("X-Error-Stacktrace", message );
// response.addHeader("X-Error-Classname", name);
//// String param = RemoteMethodSerialization.serializeExceptionParam( e);
//// if ( param != null)
//// {
//// response.addHeader("X-Error-Param", param);
//// }
// response.setStatus( 500);
// }
// catch (Exception ex)
// {
// getLogger().error( " Error writing exception back to client " + e.getMessage(), ex);
// }
// }
// }
// private boolean isClientVersionSupported(String clientVersion) {
// // add/remove supported client versions here
// return clientVersion.equals(serverVersion) || clientVersion.equals("@doc.version@") ;
// }
//
// private Map<String,String> makeSinglesAndRemoveVersion( Map<String, String[]> parameterMap )
// {
// TreeMap<String,String> singlesMap = new TreeMap<String,String>();
// for (Iterator<String> it = parameterMap.keySet().iterator();it.hasNext();)
// {
// String key = it.next();
// if ( key.toLowerCase().equals("v"))
// {
// continue;
// }
// String[] values = parameterMap.get( key);
// if ( values != null && values.length > 0 )
// {
// singlesMap.put( key,values[0]);
// }
// else
// {
// singlesMap.put( key,null);
// }
// }
//
// return singlesMap;
//
// }
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.server;
import org.rapla.entities.Category;
import org.rapla.entities.User;
import org.rapla.framework.RaplaException;
public interface AuthenticationStore {
/** returns, if the user can be authenticated. */
boolean authenticate(String username, String password) throws RaplaException;
/** returns the name of the store */
String getName();
/** Initializes a user entity with the values provided by the authentication store.
* @return <code>true</code> if the new user-object attributes (such as email, name, or groups) differ from the values stored before the method was executed, <code>false</code> otherwise. */
boolean initUser( User user, String username, String password, Category groupRootCategory) throws RaplaException;
}
| Java |
package org.rapla.server;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
public class HTTPMethodOverrideFilter implements Filter
{
Collection<String> VALID_METHODS = Arrays.asList(new String[] {"GET","POST","DELETE","PUT","PATCH"});
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
MethodOverrideWrapper wrapper = new MethodOverrideWrapper( (HttpServletRequest) request);
chain.doFilter(wrapper, response);
HttpServletResponse hresponse = (HttpServletResponse) response;
hresponse.addHeader("Vary", "X-HTTP-Method-Override");
}
private class MethodOverrideWrapper extends HttpServletRequestWrapper
{
public MethodOverrideWrapper(HttpServletRequest request) {
super(request);
}
@Override
public String getMethod() {
String method = super.getMethod();
String newMethod = getHeader("X-HTTP-Method-Override");
if ("POST".equals(method) && newMethod != null && VALID_METHODS.contains(newMethod))
{
method = newMethod;
}
return method;
}
}
} | Java |
package org.rapla.server;
import java.util.Date;
import java.util.TimeZone;
public interface TimeZoneConverter
{
/**
returns the timezone configured via main options, this is per default the system timezon. This timezone is used for ical/exchange import/export
If Rapla will support timezones in the future, than this will be the default timezone for all times. Now its only used on import and export. It works as with system time above. 10:00am GMT+0 is converted to 10:00am of the configured timezone on export and on import all times are converted to GMT+0.
@see TimeZoneConverter#toRaplaTime(TimeZone, long)
*/
TimeZone getImportExportTimeZone();
long fromRaplaTime(TimeZone timeZone,long raplaTime);
long toRaplaTime(TimeZone timeZone,long time);
Date fromRaplaTime(TimeZone timeZone,Date raplaTime);
/**
* converts a common Date object into a Date object that
* assumes that the user (being in the given timezone) is in the
* UTC-timezone by adding the offset between UTC and the given timezone.
*
* <pre>
* Example: If you pass the Date "2013 Jan 15 11:00:00 UTC"
* and the TimeZone "GMT+1", this method will return a Date
* "2013 Jan 15 12:00:00 UTC" which is effectivly 11:00:00 GMT+1
* </pre>
*
* @param timeZone
* the orgin timezone
* @param time
* the Date object in the passed timezone
* @see fromRaplaTime
*/
Date toRaplaTime(TimeZone timeZone,Date time);
} | Java |
package org.rapla.server;
import org.rapla.framework.RaplaContextException;
public interface RemoteMethodFactory<T> {
public T createService(final RemoteSession remoteSession) throws RaplaContextException;
}
| Java |
package org.rapla.server;
import org.rapla.framework.TypedComponentRole;
import org.rapla.gui.SwingViewFactory;
import org.rapla.plugin.abstractcalendar.server.HTMLViewFactory;
import org.rapla.servletpages.RaplaMenuGenerator;
import org.rapla.servletpages.ServletRequestPreprocessor;
/** Constant Pool of basic extension points of the Rapla server.
* You can add your extension in the provideService Method of your PluginDescriptor
* <pre>
* container.addContainerProvidedComponent( REPLACE_WITH_EXTENSION_POINT_NAME, REPLACE_WITH_CLASS_IMPLEMENTING_EXTENSION, config);
* </pre>
* @see org.rapla.framework.PluginDescriptor
*/
public class RaplaServerExtensionPoints {
/** add your own views to Rapla, by providing a org.rapla.gui.ViewFactory
* @see SwingViewFactory
* */
public static final Class<HTMLViewFactory> HTML_CALENDAR_VIEW_EXTENSION = HTMLViewFactory.class;
/** A server extension is started automaticaly when the server is up and running and connected to a data store. A class added as service doesn't need to implement a specific interface and is instanciated automaticaly after server start. You can add a RaplaContext parameter to your constructor to get access to the services of rapla.
* */
public static final Class<ServerExtension> SERVER_EXTENSION = ServerExtension.class;
/** you can add servlet pre processer to manipulate request and response before standard processing is
* done by rapla
*/
public static final Class<ServletRequestPreprocessor> SERVLET_REQUEST_RESPONSE_PREPROCESSING_POINT = ServletRequestPreprocessor.class;
/** you can add your own entries on the index page Just add a HTMLMenuEntry to the list
@see RaplaMenuGenerator
* */
public static final TypedComponentRole<RaplaMenuGenerator> HTML_MAIN_MENU_EXTENSION_POINT = new TypedComponentRole<RaplaMenuGenerator>("org.rapla.servletpages");
//public final static TypedComponentRole<List<PluginDescriptor<ServerServiceContainer>>> SERVER_PLUGIN_LIST = new TypedComponentRole<List<PluginDescriptor<ServerServiceContainer>>>("server-plugin-list");
} | Java |
package org.rapla.server;
/**
* a class implementing server extension is started automatically when the server is up and running and connected to a data store.
*
*/
public interface ServerExtension {
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.server;
import org.rapla.entities.User;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.logger.Logger;
/** An interface to access the SessionInformation. An implementation of
* RemoteSession gets passed to the creation RaplaRemoteService.*/
public interface RemoteSession
{
boolean isAuthentified();
User getUser() throws RaplaContextException;
Logger getLogger();
//String getAccessToken();
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 ?, Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.server;
import org.rapla.facade.ClientFacade;
import org.rapla.framework.RaplaContext;
/** Encapsulates a StorageOperator. This service is responsible for
<ul>
<li>synchronizing update and remove request from clients and passing
them to the storage-operator</li>
<li>authentification of the clients</li>
<li>notifying subscribed clients when the stored-data has
changed</li>
</ul>
*/
public interface ServerService {
ClientFacade getFacade();
RaplaContext getContext();
}
| Java |
package org.rapla.server.internal;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.LinkedHashMap;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.rapla.RaplaMainContainer;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.Configuration;
import org.rapla.framework.RaplaContext;
import org.rapla.servletpages.RaplaPageGenerator;
public class RaplaConfPageGenerator extends RaplaComponent implements RaplaPageGenerator{
public RaplaConfPageGenerator(RaplaContext context) {
super(context);
}
public void generatePage( ServletContext context, HttpServletRequest request, HttpServletResponse response ) throws IOException {
java.io.PrintWriter out = response.getWriter();
response.setContentType("application/xml;charset=utf-8");
out.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
out.println("<rapla-config>");
Configuration conf = getService(RaplaMainContainer.RAPLA_MAIN_CONFIGURATION);
//<!-- Use this to customize the rapla resources
//<default-bundle>org.rapla.MyResources</default-bundle>
//-->
Configuration localeConf = conf.getChild("locale");
if ( localeConf != null)
{
printConfiguration( out, localeConf);
}
Configuration[] bundles = conf.getChildren("default-bundle");
for ( Configuration bundle: bundles)
{
printConfiguration( out, bundle);
}
String remoteId = null;
Configuration[] clients = conf.getChildren("rapla-client");
for ( Configuration client: clients)
{
if ( client.getAttribute("id", "").equals( "client"))
{
remoteId = client.getChild("facade").getChild("store").getValue( "remote");
printConfiguration( out, client);
break;
}
}
if ( remoteId != null)
{
Configuration[] storages = conf.getChildren("remote-storage");
for ( Configuration storage: storages)
{
if ( storage.getAttribute("id", "").equals( remoteId))
{
printConfiguration( out, storage);
}
}
}
else
{
// Config not found use default
out.println("<rapla-client id=\"client\">");
out.println(" <facade id=\"facade\">");
out.println(" <store>remote</store>");
out.println(" </facade>");
out.println("</rapla-client>");
out.println(" ");
out.println("<remote-storage id=\"remote\">");
out.println(" <server>${download-url}</server>");
out.println("</remote-storage>");
}
out.println(" ");
out.println("</rapla-config>");
out.close();
}
private void printConfiguration(PrintWriter out, Configuration conf) throws IOException {
ConfigurationWriter configurationWriter = new ConfigurationWriter();
BufferedWriter writer = new BufferedWriter( out);
configurationWriter.setWriter( writer);
configurationWriter.printConfiguration( conf);
writer.flush();
}
class ConfigurationWriter extends org.rapla.components.util.xml.XMLWriter
{
private void printConfiguration(Configuration element) throws IOException {
LinkedHashMap<String, String> attr = new LinkedHashMap<String, String>();
String[] attrNames = element.getAttributeNames();
if( null != attrNames )
{
for( int i = 0; i < attrNames.length; i++ )
{
String key = attrNames[ i ];
String value = element.getAttribute( attrNames[ i ], "" );
attr.put(key,value);
}
}
String qName = element.getName();
openTag(qName);
att(attr);
Configuration[] children = element.getChildren();
if (children.length > 0)
{
closeTag();
for( int i = 0; i < children.length; i++ )
{
printConfiguration( children[ i ] );
}
closeElement(qName);
}
else
{
String value = element.getValue( null );
if (null == value)
{
closeElementTag();
}
else
{
closeTagOnLine();
print(value);
closeElementOnLine(qName);
println();
}
}
}
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2013 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.server.internal;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
import javax.servlet.http.HttpServletRequest;
import net.fortuna.ical4j.model.TimeZoneRegistry;
import net.fortuna.ical4j.model.TimeZoneRegistryFactory;
import org.rapla.ConnectInfo;
import org.rapla.RaplaMainContainer;
import org.rapla.components.xmlbundle.I18nBundle;
import org.rapla.entities.Category;
import org.rapla.entities.Entity;
import org.rapla.entities.User;
import org.rapla.entities.configuration.Preferences;
import org.rapla.entities.configuration.RaplaConfiguration;
import org.rapla.entities.domain.Permission;
import org.rapla.entities.internal.UserImpl;
import org.rapla.facade.ClientFacade;
import org.rapla.facade.RaplaComponent;
import org.rapla.facade.internal.FacadeImpl;
import org.rapla.framework.Configuration;
import org.rapla.framework.DefaultConfiguration;
import org.rapla.framework.PluginDescriptor;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.RaplaException;
import org.rapla.framework.RaplaLocale;
import org.rapla.framework.internal.ComponentInfo;
import org.rapla.framework.internal.ContainerImpl;
import org.rapla.framework.internal.RaplaLocaleImpl;
import org.rapla.framework.internal.RaplaMetaConfigInfo;
import org.rapla.framework.logger.Logger;
import org.rapla.plugin.export2ical.Export2iCalPlugin;
import org.rapla.rest.gwtjsonrpc.common.FutureResult;
import org.rapla.rest.gwtjsonrpc.common.ResultImpl;
import org.rapla.rest.gwtjsonrpc.common.VoidResult;
import org.rapla.rest.gwtjsonrpc.server.SignedToken;
import org.rapla.rest.gwtjsonrpc.server.ValidToken;
import org.rapla.rest.gwtjsonrpc.server.XsrfException;
import org.rapla.rest.server.RaplaAPIPage;
import org.rapla.rest.server.RaplaAuthRestPage;
import org.rapla.rest.server.RaplaDynamicTypesRestPage;
import org.rapla.rest.server.RaplaEventsRestPage;
import org.rapla.rest.server.RaplaResourcesRestPage;
import org.rapla.server.AuthenticationStore;
import org.rapla.server.RaplaKeyStorage;
import org.rapla.server.RaplaServerExtensionPoints;
import org.rapla.server.RemoteMethodFactory;
import org.rapla.server.RemoteSession;
import org.rapla.server.ServerService;
import org.rapla.server.ServerServiceContainer;
import org.rapla.server.TimeZoneConverter;
import org.rapla.servletpages.DefaultHTMLMenuEntry;
import org.rapla.servletpages.RaplaAppletPageGenerator;
import org.rapla.servletpages.RaplaIndexPageGenerator;
import org.rapla.servletpages.RaplaJNLPPageGenerator;
import org.rapla.servletpages.RaplaPageGenerator;
import org.rapla.servletpages.RaplaStatusPageGenerator;
import org.rapla.servletpages.RaplaStorePage;
import org.rapla.storage.CachableStorageOperator;
import org.rapla.storage.RaplaSecurityException;
import org.rapla.storage.StorageOperator;
import org.rapla.storage.StorageUpdateListener;
import org.rapla.storage.UpdateResult;
import org.rapla.storage.dbrm.LoginCredentials;
import org.rapla.storage.dbrm.LoginTokens;
import org.rapla.storage.dbrm.RemoteConnectionInfo;
import org.rapla.storage.dbrm.RemoteMethodStub;
import org.rapla.storage.dbrm.RemoteServer;
import org.rapla.storage.dbrm.RemoteStorage;
import org.rapla.storage.impl.server.LocalAbstractCachableOperator;
/** Default implementation of StorageService.
* <p>Sample configuration 1:
<pre>
<storage id="storage" >
<store>file</store>
</storage>
</pre>
* The store value contains the id of a storage-component.
* Storage-Components are all components that implement the
* <code>CachableStorageOperator<code> interface.
*
* </p>
@see ServerService
*/
public class ServerServiceImpl extends ContainerImpl implements StorageUpdateListener, ServerServiceContainer, ServerService, ShutdownService, RemoteMethodFactory<RemoteServer>,RemoteMethodStub
{
@SuppressWarnings("rawtypes")
public static Class<RemoteMethodFactory> REMOTE_METHOD_FACTORY = RemoteMethodFactory.class;
static Class<RaplaPageGenerator> SERVLET_PAGE_EXTENSION = RaplaPageGenerator.class;
protected CachableStorageOperator operator;
protected I18nBundle i18n;
List<PluginDescriptor<ServerServiceContainer>> pluginList;
ClientFacade facade;
private AuthenticationStore authenticationStore;
SignedToken accessTokenSigner;
SignedToken refreshTokenSigner;
RemoteSessionImpl standaloneSession;
ShutdownService shutdownService;
// 5 Hours until the token expires
int accessTokenValiditySeconds = 300 * 60;
public ServerServiceImpl( RaplaContext parentContext, Configuration config, Logger logger) throws RaplaException
{
super( parentContext, config, logger );
addContainerProvidedComponent( TimeZoneConverter.class, TimeZoneConverterImpl.class);
i18n = parentContext.lookup( RaplaComponent.RAPLA_RESOURCES );
Configuration login = config.getChild( "login" );
String username = login.getChild( "username" ).getValue( null );
String password = login.getChild( "password" ).getValue( "" );
RaplaContext context = getContext();
if ( config.getChildren("facade").length >0 )
{
facade = m_context.lookup(ClientFacade.class);
}
else
{
// for old raplaserver.xconf
facade = new FacadeImpl( context, config, getLogger().getChildLogger("serverfacade") );
}
operator = (CachableStorageOperator) facade.getOperator();
addContainerProvidedComponentInstance( ServerService.class, this);
addContainerProvidedComponentInstance( ShutdownService.class, this);
addContainerProvidedComponentInstance( ServerServiceContainer.class, this);
addContainerProvidedComponentInstance( CachableStorageOperator.class, operator );
addContainerProvidedComponentInstance( StorageOperator.class, operator );
addContainerProvidedComponentInstance( ClientFacade.class, facade );
addContainerProvidedComponent( SecurityManager.class, SecurityManager.class );
addRemoteMethodFactory(RemoteStorage.class,RemoteStorageImpl.class, null);
addContainerProvidedComponentInstance( REMOTE_METHOD_FACTORY, this, RemoteServer.class.getName() );
// adds 5 basic pages to the webapplication
addWebpage( "server",RaplaStatusPageGenerator.class);
addWebpage( "json",RaplaAPIPage.class);
addWebpage( "resources",RaplaResourcesRestPage.class);
addWebpage( "events",RaplaEventsRestPage.class);
addWebpage( "dynamictypes",RaplaDynamicTypesRestPage.class);
addWebpage( "auth",RaplaAuthRestPage.class);
addWebpage( "index",RaplaIndexPageGenerator.class );
addWebpage( "raplaclient.jnlp",RaplaJNLPPageGenerator.class );
addWebpage( "raplaclient",RaplaJNLPPageGenerator.class );
addWebpage( "raplaapplet",RaplaAppletPageGenerator.class );
addWebpage( "store",RaplaStorePage.class);
addWebpage( "raplaclient.xconf",RaplaConfPageGenerator.class );
addWebpage( "raplaclient.xconf",RaplaConfPageGenerator.class);
I18nBundle i18n = context.lookup(RaplaComponent.RAPLA_RESOURCES);
// Index page menu
addContainerProvidedComponentInstance( RaplaServerExtensionPoints.HTML_MAIN_MENU_EXTENSION_POINT, new DefaultHTMLMenuEntry(context,i18n.getString( "start_rapla_with_webstart" ),"rapla/raplaclient.jnlp") );
addContainerProvidedComponentInstance( RaplaServerExtensionPoints.HTML_MAIN_MENU_EXTENSION_POINT, new DefaultHTMLMenuEntry(context,i18n.getString( "start_rapla_with_applet" ),"rapla?page=raplaapplet") );
addContainerProvidedComponentInstance( RaplaServerExtensionPoints.HTML_MAIN_MENU_EXTENSION_POINT, new DefaultHTMLMenuEntry(context,i18n.getString( "server_status" ),"rapla?page=server") );
standaloneSession = new RemoteSessionImpl(getContext(), "session");
operator.addStorageUpdateListener( this );
if ( username != null )
operator.connect( new ConnectInfo(username, password.toCharArray()));
else
operator.connect();
Set<String> pluginNames;
//List<PluginDescriptor<ClientServiceContainer>> pluginList;
try {
pluginNames = context.lookup( RaplaMainContainer.PLUGIN_LIST);
} catch (RaplaContextException ex) {
throw new RaplaException (ex );
}
pluginList = new ArrayList<PluginDescriptor<ServerServiceContainer>>( );
Logger pluginLogger = getLogger().getChildLogger("plugin");
for ( String plugin:pluginNames)
{
try {
boolean found = false;
try {
Class<?> componentClass = ServerServiceImpl.class.getClassLoader().loadClass( plugin );
Method[] methods = componentClass.getMethods();
for ( Method method:methods)
{
if ( method.getName().equals("provideServices"))
{
Class<?> type = method.getParameterTypes()[0];
if (ServerServiceContainer.class.isAssignableFrom(type))
{
found = true;
}
}
}
} catch (ClassNotFoundException e1) {
} catch (Exception e1) {
getLogger().warn(e1.getMessage());
continue;
}
if ( found )
{
@SuppressWarnings("unchecked")
PluginDescriptor<ServerServiceContainer> descriptor = (PluginDescriptor<ServerServiceContainer>) instanciate(plugin, null, logger);
pluginList.add(descriptor);
pluginLogger.info("Installed plugin "+plugin);
}
} catch (RaplaContextException e) {
if (e.getCause() instanceof ClassNotFoundException) {
pluginLogger.error("Could not instanciate plugin "+ plugin, e);
}
}
}
addContainerProvidedComponent(RaplaKeyStorage.class, RaplaKeyStorageImpl.class);
try {
RaplaKeyStorage keyStorage = getContext().lookup( RaplaKeyStorage.class);
String secretKey = keyStorage.getRootKeyBase64();
accessTokenSigner = new SignedToken(accessTokenValiditySeconds , secretKey);
refreshTokenSigner = new SignedToken(-1 , secretKey);
} catch (Exception e) {
throw new RaplaException( e.getMessage(), e);
}
Preferences preferences = operator.getPreferences( null, true );
//RaplaConfiguration encryptionConfig = preferences.getEntry(EncryptionService.CONFIG);
//addRemoteMethodFactory( EncryptionService.class, EncryptionServiceFactory.class);
RaplaConfiguration entry = preferences.getEntry(RaplaComponent.PLUGIN_CONFIG);
String importExportTimeZone = TimeZone.getDefault().getID();
if ( entry != null)
{
Configuration find = entry.find("class", Export2iCalPlugin.PLUGIN_CLASS);
if ( find != null)
{
String timeZone = find.getChild("TIMEZONE").getValue( null);
if ( timeZone != null && !timeZone.equals("Etc/UTC"))
{
importExportTimeZone = timeZone;
}
}
}
String timezoneId = preferences.getEntryAsString(RaplaMainContainer.TIMEZONE, importExportTimeZone);
RaplaLocale raplaLocale = context.lookup(RaplaLocale.class);
TimeZoneConverter importExportLocale = context.lookup(TimeZoneConverter.class);
try {
TimeZoneRegistry registry = TimeZoneRegistryFactory.getInstance().createRegistry();
TimeZone timeZone = registry.getTimeZone(timezoneId);
((RaplaLocaleImpl) raplaLocale).setImportExportTimeZone( timeZone);
((TimeZoneConverterImpl) importExportLocale).setImportExportTimeZone( timeZone);
if ( operator instanceof LocalAbstractCachableOperator)
{
((LocalAbstractCachableOperator) operator).setTimeZone( timeZone);
}
} catch (Exception rc) {
getLogger().error("Timezone " + timezoneId + " not found. " + rc.getMessage() + " Using system timezone " + importExportLocale.getImportExportTimeZone());
}
initializePlugins( pluginList, preferences );
if ( context.has( AuthenticationStore.class ) )
{
try
{
authenticationStore = context.lookup( AuthenticationStore.class );
getLogger().info( "Using AuthenticationStore " + authenticationStore.getName() );
}
catch ( RaplaException ex)
{
getLogger().error( "Can't initialize configured authentication store. Using default authentication." , ex);
}
}
// Provider<EntityStore> storeProvider = new Provider<EntityStore>()
// {
// public EntityStore get() {
// return new EntityStore(operator, operator.getSuperCategory());
// }
//
// };
}
@Override
protected Map<String,ComponentInfo> getComponentInfos() {
return new RaplaMetaConfigInfo();
}
public <T> void addRemoteMethodFactory(Class<T> role, Class<? extends RemoteMethodFactory<T>> factory) {
addRemoteMethodFactory(role, factory, null);
}
public <T> void addRemoteMethodFactory(Class<T> role, Class<? extends RemoteMethodFactory<T>> factory, Configuration configuration) {
addContainerProvidedComponent(REMOTE_METHOD_FACTORY,factory, role.getName(), configuration);
}
protected RemoteMethodFactory<?> getRemoteMethod(String interfaceName) throws RaplaContextException {
RemoteMethodFactory<?> factory = lookup( REMOTE_METHOD_FACTORY ,interfaceName);
return factory;
}
public <T extends RaplaPageGenerator> void addWebpage(String pagename,
Class<T> pageClass) {
addWebpage(pagename, pageClass, null);
}
public <T extends RaplaPageGenerator> void addWebpage(String pagename,
Class<T> pageClass, Configuration configuration) {
String lowerCase = pagename.toLowerCase();
addContainerProvidedComponent(SERVLET_PAGE_EXTENSION,pageClass, lowerCase, configuration);
}
public RaplaPageGenerator getWebpage(String page) {
try
{
String lowerCase = page.toLowerCase();
RaplaPageGenerator factory = lookup( SERVLET_PAGE_EXTENSION ,lowerCase);
return factory;
} catch (RaplaContextException ex)
{
Throwable cause = ex.getCause();
if ( cause != null)
{
getLogger().error(cause.getMessage(),cause);
}
return null;
}
}
public void updateError( RaplaException ex )
{
if ( getLogger() != null )
getLogger().error( ex.getMessage(), ex );
try
{
stop();
}
catch ( Exception e )
{
if ( getLogger() != null )
getLogger().error( e.getMessage() );
}
}
public void objectsUpdated(UpdateResult evt) {
}
/**
* @see org.rapla.server.ServerService#getFacade()
*/
public ClientFacade getFacade()
{
return facade;
}
protected void initializePlugins( List<PluginDescriptor<ServerServiceContainer>> pluginList, Preferences preferences ) throws RaplaException
{
RaplaConfiguration raplaConfig = preferences.getEntry( RaplaComponent.PLUGIN_CONFIG);
// Add plugin configs
for ( Iterator<PluginDescriptor<ServerServiceContainer>> it = pluginList.iterator(); it.hasNext(); )
{
PluginDescriptor<ServerServiceContainer> pluginDescriptor = it.next();
String pluginClassname = pluginDescriptor.getClass().getName();
Configuration pluginConfig = null;
if ( raplaConfig != null )
{
// TODO should be replaced with a more desciptve approach instead of looking for the config by guessing from the package name
pluginConfig = raplaConfig.find( "class", pluginClassname );
// If no plugin config for server is found look for plugin config for client plugin
if ( pluginConfig == null )
{
pluginClassname = pluginClassname.replaceAll("ServerPlugin", "Plugin");
pluginClassname = pluginClassname.replaceAll(".server.", ".client.");
pluginConfig = raplaConfig.find( "class", pluginClassname );
if ( pluginConfig == null)
{
pluginClassname = pluginClassname.replaceAll(".client.", ".");
pluginConfig = raplaConfig.find( "class", pluginClassname );
}
}
}
if ( pluginConfig == null )
{
pluginConfig = new DefaultConfiguration( "plugin" );
}
pluginDescriptor.provideServices( this, pluginConfig );
}
lookupServicesFor(RaplaServerExtensionPoints.SERVER_EXTENSION );
}
private void stop()
{
boolean wasConnected = operator.isConnected();
operator.removeStorageUpdateListener( this );
Logger logger = getLogger();
try
{
operator.disconnect();
}
catch (RaplaException e)
{
logger.error( "Could not disconnect operator " , e);
}
finally
{
}
if ( wasConnected )
{
logger.info( "Storage service stopped" );
}
}
public void dispose()
{
stop();
super.dispose();
}
public StorageOperator getOperator()
{
return operator;
}
public void storageDisconnected(String message)
{
try
{
stop();
}
catch ( Exception e )
{
if ( getLogger() != null )
getLogger().error( e.getMessage() );
}
}
// public byte[] dispatch(RemoteSession remoteSession, String methodName, Map<String,String> args ) throws Exception
// {
// ByteArrayOutputStream out = new ByteArrayOutputStream();
// int indexRole = methodName.indexOf( "/" );
// String interfaceName = RemoteStorage.class.getName();
// if ( indexRole > 0 )
// {
// interfaceName = methodName.substring( 0, indexRole );
// methodName = methodName.substring( indexRole + 1 );
// }
// try
// {
// final Object serviceUncasted;
// {
// Logger debugLogger = getLogger().getChildLogger(interfaceName+"."+ methodName + ".arguments" );
// if ( debugLogger.isDebugEnabled())
// {
// debugLogger.debug(args.toString());
// }
// }
// RemoteMethodFactory<?> factory = getRemoteMethod(interfaceName);
// Class<?> interfaceClass = Class.forName( interfaceName);
//
// serviceUncasted = factory.createService( remoteSession);
// Method method = findMethod( interfaceClass, methodName, args);
// if ( method == null)
// {
// throw new RaplaException("Can't find method with name " + methodName);
// }
// Class<?>[] parameterTypes = method.getParameterTypes();
// Object[] convertedArgs = remoteMethodService.deserializeArguments(parameterTypes,args);
// Object result = null;
// try
// {
// result = method.invoke( serviceUncasted, convertedArgs);
// }
// catch (InvocationTargetException ex)
// {
// Throwable cause = ex.getCause();
// if (cause instanceof RaplaException)
// {
// throw (RaplaException)cause;
// }
// else
// {
// throw new RaplaException( cause.getMessage(), cause );
// }
// }
// User user = remoteSession.isAuthentified() ? remoteSession.getUser() : null;
//
// if ( result != null)
// {
// BufferedWriter outWriter = new BufferedWriter( new OutputStreamWriter( out,"utf-8"));
// Appendable appendable = outWriter;
// // we don't trasmit password settings in the general preference entry when the user is not an admin
// remoteMethodService.serializeReturnValue(user, result, appendable);
// outWriter.flush();
// }
// else
// {
//// BufferedWriter outWriter = new BufferedWriter( new OutputStreamWriter( out,"utf-8"));
//// outWriter.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
//// outWriter.write("/n");
//// outWriter.write("<data/>");
//// outWriter.flush();
// }
// out.flush();
// }
// catch (EntityNotFoundException ex)
// {
// throw ex;
// }
// catch (DependencyException ex)
// {
// throw ex;
// }
// catch (RaplaNewVersionException ex)
// {
// throw ex;
// }
// catch (RaplaSecurityException ex)
// {
// getLogger().getChildLogger( interfaceName + "." + methodName).warn( ex.getMessage());
// throw ex;
// }
// catch ( Exception ex )
// {
// getLogger().getChildLogger( interfaceName + "." + methodName).error( ex.getMessage(), ex );
// throw ex;
// }
// out.close();
// return out.toByteArray();
// }
// private Method findMethod( Class inter,String methodName,Map<String,String> args)
// {
// Method[] methods = inter.getMethods();
// for ( Method method: methods)
// {
// if ( method.getName().equals( methodName) )
// {
// Class<?>[] parameterTypes = method.getParameterTypes();
// Annotation[][] parameterAnnotations = method.getParameterAnnotations();
// int length = parameterTypes.length;
// // Map
// //for ( int i=0;)
// if (parameterTypes.length == args.size())
// return method;
// }
// }
// return null;
// }
public RemoteServer createService(final RemoteSession session) {
return new RemoteServer() {
public Logger getLogger()
{
if ( session != null)
{
return session.getLogger();
}
else
{
return ServerServiceImpl.this.getLogger();
}
}
@Override
public void setConnectInfo(RemoteConnectionInfo info) {
}
@Override
public FutureResult<VoidResult> logout()
{
try
{
if ( session != null)
{
if ( session.isAuthentified())
{
User user = session.getUser();
if ( user != null)
{
getLogger().getChildLogger("login").info( "Request Logout " + user.getUsername());
}
((RemoteSessionImpl)session).logout();
}
}
}
catch (RaplaException ex)
{
return new ResultImpl<VoidResult>(ex);
}
return ResultImpl.VOID;
}
@Override
public FutureResult<LoginTokens> login( String username, String password, String connectAs )
{
LoginCredentials loginCredentials = new LoginCredentials(username,password,connectAs);
return auth(loginCredentials);
}
@Override
public FutureResult<LoginTokens> auth( LoginCredentials credentials )
{
try
{
User user;
String username = credentials.getUsername();
String password = credentials.getPassword();
String connectAs = credentials.getConnectAs();
boolean isStandalone = getContext().has( RemoteMethodStub.class);
if ( isStandalone)
{
String toConnect = connectAs != null && !connectAs.isEmpty() ? connectAs : username;
// don't check passwords in standalone version
user = operator.getUser( toConnect);
if ( user == null)
{
throw new RaplaSecurityException(i18n.getString("error.login"));
}
standaloneSession.setUser( user);
}
else
{
Logger logger = getLogger().getChildLogger("login");
user = authenticate(username, password, connectAs, logger);
((RemoteSessionImpl)session).setUser( user);
}
if ( connectAs != null && connectAs.length()> 0)
{
if (!operator.getUser( username).isAdmin())
{
throw new SecurityException("Non admin user is requesting change user permission!");
}
}
FutureResult<LoginTokens> generateAccessToken = generateAccessToken(user);
return generateAccessToken;
} catch (RaplaException ex) {
return new ResultImpl<LoginTokens>(ex);
}
}
private FutureResult<LoginTokens> generateAccessToken(User user) throws RaplaException {
try
{
String userId = user.getId();
Date now = operator.getCurrentTimestamp();
Date validUntil = new Date(now.getTime() + 1000 * accessTokenValiditySeconds);
String signedToken = accessTokenSigner.newToken( userId, now);
return new ResultImpl<LoginTokens>(new LoginTokens( signedToken, validUntil));
} catch (Exception e) {
throw new RaplaException(e.getMessage());
}
}
@Override
public FutureResult<String> getRefreshToken()
{
try
{
User user = getValidUser(session);
RaplaKeyStorage keyStore = getContext().lookup(RaplaKeyStorage.class);
Collection<String> apiKeys = keyStore.getAPIKeys(user);
String refreshToken;
if ( apiKeys.size() == 0)
{
refreshToken = null;
}
else
{
refreshToken = apiKeys.iterator().next();
}
return new ResultImpl<String>(refreshToken);
} catch (RaplaException ex) {
return new ResultImpl<String>(ex);
}
}
@Override
public FutureResult<String> regenerateRefreshToken()
{
try
{
User user = getValidUser(session);
RaplaKeyStorage keyStore = getContext().lookup(RaplaKeyStorage.class);
Date now = operator.getCurrentTimestamp();
String generatedAPIKey = refreshTokenSigner.newToken(user.getId(), now);
keyStore.storeAPIKey(user, "refreshToken",generatedAPIKey);
return new ResultImpl<String>(generatedAPIKey);
} catch (Exception ex) {
return new ResultImpl<String>(ex);
}
}
@Override
public FutureResult<LoginTokens> refresh(String refreshToken)
{
try
{
User user = getUser(refreshToken, refreshTokenSigner);
RaplaKeyStorage keyStore = getContext().lookup(RaplaKeyStorage.class);
Collection<String> apiKeys = keyStore.getAPIKeys(user);
if ( !apiKeys.contains( refreshToken))
{
throw new RaplaSecurityException("refreshToken not valid");
}
FutureResult<LoginTokens> generateAccessToken = generateAccessToken(user);
return generateAccessToken;
} catch (RaplaException ex) {
return new ResultImpl<LoginTokens>(ex);
}
}
public User getValidUser(final RemoteSession session) throws RaplaContextException, RaplaSecurityException {
User user = session.getUser();
if ( user == null)
{
throw new RaplaSecurityException(i18n.getString("error.login"));
}
return user;
}
};
}
public User authenticate(String username, String password,String connectAs, Logger logger) throws RaplaException,RaplaSecurityException {
User user;
String toConnect = connectAs != null && !connectAs.isEmpty() ? connectAs : username;
logger.info( "User '" + username + "' is requesting login." );
if ( authenticationStore != null )
{
logger.info("Checking external authentifiction for user " + username);
boolean authenticateExternal;
try
{
authenticateExternal = authenticationStore.authenticate( username, password );
}
catch (RaplaException ex)
{
authenticateExternal= false;
getLogger().error(ex.getMessage(), ex);
}
if (authenticateExternal)
{
logger.info("Successfull for " + username);
//@SuppressWarnings("unchecked")
user = operator.getUser( username );
if ( user == null )
{
logger.info("User not found in localstore. Creating new Rapla user " + username);
Date now = operator.getCurrentTimestamp();
UserImpl newUser = new UserImpl(now,now);
newUser.setId( operator.createIdentifier( User.TYPE,1 )[0] );
user = newUser;
}
else
{
Set<Entity>singleton = Collections.singleton((Entity)user);
Collection<Entity> editList = operator.editObjects( singleton, null );
user = (User)editList.iterator().next();
}
boolean initUser ;
try
{
Category groupCategory = operator.getSuperCategory().getCategory( Permission.GROUP_CATEGORY_KEY );
logger.info("Looking for update for rapla user '" + username + "' from external source.");
initUser = authenticationStore.initUser( (User) user, username, password, groupCategory );
} catch (RaplaSecurityException ex){
throw new RaplaSecurityException(i18n.getString("error.login"));
}
if ( initUser )
{
logger.info("Udating rapla user '" + username + "' from external source.");
List<Entity>storeList = new ArrayList<Entity>(1);
storeList.add( user);
List<Entity>removeList = Collections.emptyList();
operator.storeAndRemove( storeList, removeList, null );
}
else
{
logger.info("User '" + username + "' already up to date");
}
}
else
{
logger.info("Now trying to authenticate with local store '" + username + "'");
operator.authenticate( username, password );
}
// do nothing
} // if the authenticationStore can't authenticate the user is checked against the local database
else
{
logger.info("Check password for " + username);
operator.authenticate( username, password );
}
if ( connectAs != null && connectAs.length() > 0)
{
logger.info("Successfull login for '" + username +"' acts as user '" + connectAs + "'");
}
else
{
logger.info("Successfull login for '" + username + "'");
}
user = operator.getUser(toConnect);
if ( user == null)
{
throw new RaplaException("User with username '" + toConnect + "' not found");
}
return user;
}
public void setShutdownService(ShutdownService shutdownService) {
this.shutdownService = shutdownService;
}
public <T> T getWebserviceLocalStub(final Class<T> a) throws RaplaContextException {
@SuppressWarnings("unchecked")
RemoteMethodFactory<T> factory =lookup( REMOTE_METHOD_FACTORY ,a.getName());
T service = factory.createService( standaloneSession);
return service;
}
public void shutdown(boolean restart) {
if ( shutdownService != null)
{
shutdownService.shutdown(restart);
}
else
{
getLogger().error("Shutdown service not set");
}
}
public RemoteSession getRemoteSession(HttpServletRequest request) throws RaplaException {
User user = getUser(request);
RemoteSessionImpl remoteSession = new RemoteSessionImpl(getContext(), user != null ? user.getUsername() : "anonymous");
remoteSession.setUser( (User) user);
// remoteSession.setAccessToken( token );
return remoteSession;
}
public User getUser(HttpServletRequest request) throws RaplaException {
String token = request.getHeader("Authorization");
if ( token != null)
{
String bearerStr = "bearer";
int bearer = token.toLowerCase().indexOf(bearerStr);
if ( bearer >= 0)
{
token = token.substring( bearer + bearerStr.length()).trim();
}
}
else
{
token = request.getParameter("access_token");
}
User user = null;
if ( token == null)
{
String username = request.getParameter("username");
if ( username != null)
{
user = getUserWithoutPassword(username);
}
}
if ( user == null)
{
user = getUser( token, accessTokenSigner);
}
return user;
}
@SuppressWarnings("unchecked")
@Override
public <T> T createWebservice(Class<T> role, HttpServletRequest request) throws RaplaException
{
RemoteMethodFactory<T> remoteMethod = (RemoteMethodFactory<T>) getRemoteMethod( role.getName());
RemoteSession remoteSession = getRemoteSession(request);
return remoteMethod.createService(remoteSession);
}
@Override
public boolean hasWebservice(String interfaceName) {
try {
lookup( REMOTE_METHOD_FACTORY ,interfaceName);
} catch (RaplaContextException e) {
return false;
}
return true;
}
private User getUserWithoutPassword(String username) throws RaplaException
{
String connectAs = null;
User user = authenticate(username, "", connectAs, getLogger());
return user;
}
private User getUser(String tokenString,SignedToken tokenSigner) throws RaplaException
{
if ( tokenString == null)
{
return null;
}
final int s = tokenString.indexOf('$');
if (s <= 0) {
return null;
}
final String recvText = tokenString.substring(s + 1);
try {
Date now = operator.getCurrentTimestamp();
ValidToken checkToken = tokenSigner.checkToken(tokenString, recvText, now);
if ( checkToken == null)
{
throw new RaplaSecurityException(RemoteStorage.USER_WAS_NOT_AUTHENTIFIED + " InvalidToken " + tokenString);
}
} catch (XsrfException e) {
throw new RaplaSecurityException(e.getMessage(), e);
}
String userId = recvText;
User user = operator.resolve( userId, User.class);
return user;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2013 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.server.internal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TimeZone;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import org.rapla.RaplaMainContainer;
import org.rapla.components.util.DateTools;
import org.rapla.components.util.ParseDateException;
import org.rapla.components.util.SerializableDateTimeFormat;
import org.rapla.components.util.TimeInterval;
import org.rapla.components.xmlbundle.I18nBundle;
import org.rapla.entities.Category;
import org.rapla.entities.DependencyException;
import org.rapla.entities.Entity;
import org.rapla.entities.EntityNotFoundException;
import org.rapla.entities.RaplaObject;
import org.rapla.entities.RaplaType;
import org.rapla.entities.User;
import org.rapla.entities.configuration.Preferences;
import org.rapla.entities.configuration.RaplaConfiguration;
import org.rapla.entities.configuration.internal.PreferencesImpl;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Appointment;
import org.rapla.entities.domain.Permission;
import org.rapla.entities.domain.Reservation;
import org.rapla.entities.domain.internal.AppointmentImpl;
import org.rapla.entities.domain.internal.ReservationImpl;
import org.rapla.entities.dynamictype.Classifiable;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.entities.dynamictype.internal.DynamicTypeImpl;
import org.rapla.entities.storage.EntityReferencer;
import org.rapla.facade.ClientFacade;
import org.rapla.facade.Conflict;
import org.rapla.facade.RaplaComponent;
import org.rapla.facade.internal.ConflictImpl;
import org.rapla.framework.DefaultConfiguration;
import org.rapla.framework.Disposable;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.RaplaException;
import org.rapla.framework.RaplaLocale;
import org.rapla.framework.TypedComponentRole;
import org.rapla.framework.logger.Logger;
import org.rapla.plugin.mail.MailPlugin;
import org.rapla.plugin.mail.server.MailInterface;
import org.rapla.rest.gwtjsonrpc.common.FutureResult;
import org.rapla.rest.gwtjsonrpc.common.ResultImpl;
import org.rapla.rest.gwtjsonrpc.common.VoidResult;
import org.rapla.server.AuthenticationStore;
import org.rapla.server.RemoteMethodFactory;
import org.rapla.server.RemoteSession;
import org.rapla.storage.CachableStorageOperator;
import org.rapla.storage.PreferencePatch;
import org.rapla.storage.RaplaNewVersionException;
import org.rapla.storage.RaplaSecurityException;
import org.rapla.storage.StorageOperator;
import org.rapla.storage.StorageUpdateListener;
import org.rapla.storage.UpdateEvent;
import org.rapla.storage.UpdateResult;
import org.rapla.storage.UpdateResult.Change;
import org.rapla.storage.UpdateResult.Remove;
import org.rapla.storage.dbrm.RemoteConnectionInfo;
import org.rapla.storage.dbrm.RemoteStorage;
import org.rapla.storage.impl.EntityStore;
/** Provides an adapter for each client-session to their shared storage operator
* Handles security and synchronizing aspects.
*/
public class RemoteStorageImpl implements RemoteMethodFactory<RemoteStorage>, StorageUpdateListener, Disposable {
CachableStorageOperator operator;
protected SecurityManager security;
RaplaContext context;
int cleanupPointVersion = 0;
protected AuthenticationStore authenticationStore;
Logger logger;
ClientFacade facade;
RaplaLocale raplaLocale;
//private Map<String,Long> updateMap = new HashMap<String,Long>();
//private Map<String,Long> removeMap = new HashMap<String,Long>();
public RemoteStorageImpl(RaplaContext context) throws RaplaException {
this.context = context;
this.logger = context.lookup( Logger.class);
facade = context.lookup( ClientFacade.class);
raplaLocale = context.lookup( RaplaLocale.class);
operator = (CachableStorageOperator)facade.getOperator();
operator.addStorageUpdateListener( this);
security = context.lookup( SecurityManager.class);
if ( context.has( AuthenticationStore.class ) )
{
try
{
authenticationStore = context.lookup( AuthenticationStore.class );
getLogger().info( "Using AuthenticationStore " + authenticationStore.getName() );
}
catch ( RaplaException ex)
{
getLogger().error( "Can't initialize configured authentication store. Using default authentication." , ex);
}
}
Long repositoryVersion = operator.getCurrentTimestamp().getTime();
// Invalidate all clients
for ( User user:operator.getUsers())
{
String userId = user.getId();
needResourceRefresh.put( userId, repositoryVersion);
needConflictRefresh.put( userId, repositoryVersion);
}
synchronized (invalidateMap)
{
invalidateMap.put( repositoryVersion, new TimeInterval( null, null));
}
}
public Logger getLogger() {
return logger;
}
public I18nBundle getI18n() throws RaplaException {
return context.lookup(RaplaComponent.RAPLA_RESOURCES);
}
static UpdateEvent createTransactionSafeUpdateEvent( UpdateResult updateResult )
{
User user = updateResult.getUser();
UpdateEvent saveEvent = new UpdateEvent();
if ( user != null )
{
saveEvent.setUserId( user.getId() );
}
{
Iterator<UpdateResult.Add> it = updateResult.getOperations( UpdateResult.Add.class );
while ( it.hasNext() )
{
Entity newEntity = (Entity) ( it.next() ).getNew();
saveEvent.putStore( newEntity );
}
}
{
Iterator<UpdateResult.Change> it = updateResult.getOperations( UpdateResult.Change.class );
while ( it.hasNext() )
{
Entity newEntity = (Entity) ( it.next() ).getNew();
saveEvent.putStore( newEntity );
}
}
{
Iterator<UpdateResult.Remove> it = updateResult.getOperations( UpdateResult.Remove.class );
while ( it.hasNext() )
{
Entity removeEntity = (Entity) (it.next() ).getCurrent();
saveEvent.putRemove( removeEntity );
}
}
return saveEvent;
}
private Map<String,Long> needConflictRefresh = new ConcurrentHashMap<String,Long>();
private Map<String,Long> needResourceRefresh = new ConcurrentHashMap<String,Long>();
private SortedMap<Long, TimeInterval> invalidateMap = Collections.synchronizedSortedMap(new TreeMap<Long,TimeInterval>());
// Implementation of StorageUpdateListener
public void objectsUpdated( UpdateResult evt )
{
long repositoryVersion = operator.getCurrentTimestamp().getTime();
// notify the client for changes
TimeInterval invalidateInterval = evt.calulateInvalidateInterval();
if ( invalidateInterval != null)
{
long oneHourAgo = repositoryVersion - DateTools.MILLISECONDS_PER_HOUR;
// clear the entries that are older than one hour and replace them with a clear_all
// that is set one hour in the past, to refresh all clients that have not been connected in the past hour on the next connect
synchronized ( invalidateMap)
{
SortedMap<Long, TimeInterval> headMap = invalidateMap.headMap( oneHourAgo);
if ( !headMap.isEmpty())
{
Set<Long> toDelete = new TreeSet<Long>(headMap.keySet());
for ( Long key:toDelete)
{
invalidateMap.remove(key);
}
invalidateMap.put(oneHourAgo, new TimeInterval( null, null));
}
invalidateMap.put(repositoryVersion, invalidateInterval);
}
}
UpdateEvent safeResultEvent = createTransactionSafeUpdateEvent( evt );
if ( getLogger().isDebugEnabled() )
getLogger().debug( "Storage was modified. Calling notify." );
boolean addAllUsersToConflictRefresh = false;
for ( Iterator<Entity>it = safeResultEvent.getStoreObjects().iterator(); it.hasNext(); )
{
Entity obj = it.next();
if (!isTransferedToClient(obj))
{
continue;
}
if ( obj instanceof Conflict)
{
addAllUsersToConflictRefresh = true;
}
if ( obj instanceof DynamicType)
{
addAllUsersToConflictRefresh = true;
}
// RaplaType<?> raplaType = obj.getRaplaType();
// if (raplaType == Conflict.TYPE)
// {
// String id = obj.getId();
// updateMap.remove( id );
// removeMap.remove( id );
// updateMap.put( id, new Long( repositoryVersion ) );
// }
}
// now we check if a the resources have changed in a way that a user needs to refresh all resources. That is the case, when
// someone changes the permissions on one or more resource and that affects the visibility of that resource to a user,
// so its either pushed to the client or removed from it.
Set<Permission> invalidatePermissions = new HashSet<Permission>();
boolean addAllUsersToResourceRefresh = false;
{
Iterator<Remove> operations = evt.getOperations(UpdateResult.Remove.class);
while ( operations.hasNext())
{
Remove operation = operations.next();
Entity obj = operation.getCurrent();
if ( obj instanceof User)
{
String userId = obj.getId();
needConflictRefresh.remove( userId);
needResourceRefresh.remove( userId);
}
if (!isTransferedToClient(obj))
{
continue;
}
if ( obj instanceof Allocatable)
{
Permission[] oldPermissions = ((Allocatable)obj).getPermissions();
invalidatePermissions.addAll( Arrays.asList( oldPermissions));
}
if ( obj instanceof DynamicType)
{
addAllUsersToResourceRefresh = true;
addAllUsersToConflictRefresh = true;
}
if ( obj instanceof Conflict)
{
addAllUsersToConflictRefresh = true;
}
// if ( obj instanceof Conflict)
// {
// String id = obj.getId();
// updateMap.remove( id );
// removeMap.remove( id );
// removeMap.put( id, new Long( repositoryVersion ) );
// }
}
}
if (addAllUsersToResourceRefresh || addAllUsersToConflictRefresh)
{
invalidateAll(repositoryVersion, addAllUsersToResourceRefresh,addAllUsersToConflictRefresh);
}
else
{
invalidate(evt, repositoryVersion, invalidatePermissions);
}
}
private void invalidateAll(long repositoryVersion, boolean resourceRefreh, boolean conflictRefresh) {
Collection<String> allUserIds = new ArrayList<String>();
try
{
Collection<User> allUsers = operator.getUsers();
for ( User user:allUsers)
{
String id = user.getId();
allUserIds.add( id);
}
}
catch (RaplaException ex)
{
getLogger().error( ex.getMessage(), ex);
// we stay with the old list.
// keySet iterator from concurrent hashmap is thread safe
Iterator<String> iterator = needResourceRefresh.keySet().iterator();
while ( iterator.hasNext())
{
String id = iterator.next();
allUserIds.add( id);
}
}
for ( String userId :allUserIds)
{
if (resourceRefreh )
{
needResourceRefresh.put( userId, repositoryVersion);
}
if ( conflictRefresh)
{
needConflictRefresh.put( userId, repositoryVersion);
}
}
}
private void invalidate(UpdateResult evt, long repositoryVersion, Set<Permission> invalidatePermissions) {
Collection<User> allUsers;
try {
allUsers = operator.getUsers();
} catch (RaplaException e) {
// we need to invalidate all on an exception
invalidateAll(repositoryVersion, true, true);
return;
}
// We also check if a permission on a reservation has changed, so that it is no longer or new in the conflict list of a certain user.
// If that is the case we trigger an invalidate of the conflicts for a user
Set<User> usersResourceRefresh = new HashSet<User>();
Category superCategory = operator.getSuperCategory();
Set<Category> groupsConflictRefresh = new HashSet<Category>();
Set<User> usersConflictRefresh = new HashSet<User>();
Iterator<Change> operations = evt.getOperations(UpdateResult.Change.class);
while ( operations.hasNext())
{
Change operation = operations.next();
Entity newObject = operation.getNew();
if ( newObject.getRaplaType().is( Allocatable.TYPE) && isTransferedToClient(newObject))
{
Allocatable newAlloc = (Allocatable) newObject;
Allocatable current = (Allocatable) operation.getOld();
Permission[] oldPermissions = current.getPermissions();
Permission[] newPermissions = newAlloc.getPermissions();
// we leave this condition for a faster equals check
if (oldPermissions.length == newPermissions.length)
{
for (int i=0;i<oldPermissions.length;i++)
{
Permission oldPermission = oldPermissions[i];
Permission newPermission = newPermissions[i];
if (!oldPermission.equals(newPermission))
{
invalidatePermissions.add( oldPermission);
invalidatePermissions.add( newPermission);
}
}
}
else
{
HashSet<Permission> newSet = new HashSet<Permission>(Arrays.asList(newPermissions));
HashSet<Permission> oldSet = new HashSet<Permission>(Arrays.asList(oldPermissions));
{
HashSet<Permission> changed = new HashSet<Permission>( newSet);
changed.removeAll( oldSet);
invalidatePermissions.addAll(changed);
}
{
HashSet<Permission> changed = new HashSet<Permission>(oldSet);
changed.removeAll( newSet);
invalidatePermissions.addAll(changed);
}
}
}
if ( newObject.getRaplaType().is( User.TYPE))
{
User newUser = (User) newObject;
User oldUser = (User) operation.getOld();
HashSet<Category> newGroups = new HashSet<Category>(Arrays.asList(newUser.getGroups()));
HashSet<Category> oldGroups = new HashSet<Category>(Arrays.asList(oldUser.getGroups()));
if ( !newGroups.equals( oldGroups) || newUser.isAdmin() != oldUser.isAdmin())
{
usersResourceRefresh.add( newUser);
}
}
if ( newObject.getRaplaType().is( Reservation.TYPE))
{
Reservation newEvent = (Reservation) newObject;
Reservation oldEvent = (Reservation) operation.getOld();
User newOwner = newEvent.getOwner();
User oldOwner = oldEvent.getOwner();
if ( newOwner != null && oldOwner != null && (newOwner.equals( oldOwner)) )
{
usersConflictRefresh.add( newOwner);
usersConflictRefresh.add( oldOwner);
}
Collection<Category> newGroup = RaplaComponent.getPermissionGroups( newEvent, superCategory, ReservationImpl.PERMISSION_MODIFY, false);
Collection<Category> oldGroup = RaplaComponent.getPermissionGroups( oldEvent, superCategory, ReservationImpl.PERMISSION_MODIFY, false);
if (newGroup != null && (oldGroup == null || !oldGroup.equals(newGroup)))
{
groupsConflictRefresh.addAll( newGroup);
}
if (oldGroup != null && (newGroup == null || !oldGroup.equals(newGroup)))
{
groupsConflictRefresh.addAll( oldGroup);
}
}
}
boolean addAllUsersToConflictRefresh = groupsConflictRefresh.contains( superCategory);
Set<Category> groupsResourceRefrsesh = new HashSet<Category>();
if ( !invalidatePermissions.isEmpty() || ! addAllUsersToConflictRefresh || !! groupsConflictRefresh.isEmpty())
{
for ( Permission permission:invalidatePermissions)
{
User user = permission.getUser();
if ( user != null)
{
usersResourceRefresh.add( user);
}
Category group = permission.getGroup();
if ( group != null)
{
groupsResourceRefrsesh.add( group);
}
if ( user == null && group == null)
{
usersResourceRefresh.addAll( allUsers);
break;
}
}
for ( User user:allUsers)
{
if ( usersResourceRefresh.contains( user))
{
continue;
}
for (Category group:user.getGroups())
{
if ( groupsResourceRefrsesh.contains( group))
{
usersResourceRefresh.add( user);
break;
}
if ( addAllUsersToConflictRefresh || groupsConflictRefresh.contains( group))
{
usersConflictRefresh.add( user);
break;
}
}
}
}
for ( User user:usersResourceRefresh)
{
String userId = user.getId();
needResourceRefresh.put( userId, repositoryVersion);
needConflictRefresh.put( userId, repositoryVersion);
}
for ( User user:usersConflictRefresh)
{
String userId = user.getId();
needConflictRefresh.put( userId, repositoryVersion);
}
}
private boolean isTransferedToClient(RaplaObject obj)
{
RaplaType<?> raplaType = obj.getRaplaType();
if (raplaType == Appointment.TYPE || raplaType == Reservation.TYPE)
{
return false;
}
if ( obj instanceof DynamicType)
{
if (!DynamicTypeImpl.isTransferedToClient(( DynamicType) obj))
{
return false;
}
}
if ( obj instanceof Classifiable)
{
if (!DynamicTypeImpl.isTransferedToClient(( Classifiable) obj))
{
return false;
}
}
return true;
}
@Override
public void dispose() {
}
public void updateError(RaplaException ex) {
}
public void storageDisconnected(String disconnectionMessage) {
}
public Class<RemoteStorage> getServiceClass() {
return RemoteStorage.class;
}
@Override
public RemoteStorage createService(final RemoteSession session) {
return new RemoteStorage() {
@Override
public void setConnectInfo(RemoteConnectionInfo info) {
// do nothing here
}
public FutureResult<UpdateEvent> getResources()
{
try
{
checkAuthentified();
User user = getSessionUser();
getLogger().debug ("A RemoteServer wants to get all resource-objects.");
Date serverTime = operator.getCurrentTimestamp();
Collection<Entity> visibleEntities = operator.getVisibleEntities(user);
UpdateEvent evt = new UpdateEvent();
evt.setUserId( user.getId());
for ( Entity entity: visibleEntities)
{
if ( isTransferedToClient(entity))
{
if ( entity instanceof Preferences)
{
Preferences preferences = (Preferences)entity;
User owner = preferences.getOwner();
if ( owner == null && !user.isAdmin())
{
entity = removeServerOnlyPreferences(preferences);
}
}
evt.putStore(entity);
}
}
evt.setLastValidated(serverTime);
return new ResultImpl<UpdateEvent>( evt);
}
catch (RaplaException ex )
{
return new ResultImpl<UpdateEvent>(ex );
}
}
private Preferences removeServerOnlyPreferences(Preferences preferences)
{
Preferences clone = preferences.clone();
{
//removeOldPluginConfigs(preferences, clone);
for (String role :((PreferencesImpl)preferences).getPreferenceEntries())
{
if ( role.contains(".server."))
{
clone.removeEntry(role);
}
}
}
return clone;
}
// private void removeOldPluginConfigs(Preferences preferences, Preferences clone) {
// List<String> adminOnlyPreferences = new ArrayList<String>();
// adminOnlyPreferences.add(MailPlugin.class.getCanonicalName());
// adminOnlyPreferences.add(JNDIPlugin.class.getCanonicalName());
//
// RaplaConfiguration entry = preferences.getEntry(RaplaComponent.PLUGIN_CONFIG);
// if ( entry != null)
// {
// RaplaConfiguration newConfig = entry.clone();
// for ( String className: adminOnlyPreferences)
// {
// DefaultConfiguration pluginConfig = (DefaultConfiguration)newConfig.find("class", className);
// if ( pluginConfig != null)
// {
// newConfig.removeChild( pluginConfig);
// boolean enabled = pluginConfig.getAttributeAsBoolean("enabled", false);
// RaplaConfiguration newPluginConfig = new RaplaConfiguration(pluginConfig.getName());
// newPluginConfig.setAttribute("enabled", enabled);
// newPluginConfig.setAttribute("class", className);
// newConfig.addChild( newPluginConfig);
// }
// }
// clone.putEntry(RaplaComponent.PLUGIN_CONFIG, newConfig);
// }
// }
public FutureResult<List<String>> getTemplateNames()
{
try
{
checkAuthentified();
Collection<String> templateNames = operator.getTemplateNames();
return new ResultImpl<List<String>>(new ArrayList<String>(templateNames));
}
catch (RaplaException ex )
{
return new ResultImpl<List<String>>(ex);
}
}
public FutureResult<UpdateEvent> getEntityRecursive(String... ids)
{
//synchronized (operator.getLock())
try
{
checkAuthentified();
Date repositoryVersion = operator.getCurrentTimestamp();
User sessionUser = getSessionUser();
ArrayList<Entity>completeList = new ArrayList<Entity>();
for ( String id:ids)
{
Entity entity = operator.resolve(id);
if ( entity instanceof Classifiable)
{
if (!DynamicTypeImpl.isTransferedToClient(( Classifiable) entity))
{
throw new RaplaSecurityException("Entity for id " + id + " is not transferable to the client");
}
}
if ( entity instanceof DynamicType)
{
if (!DynamicTypeImpl.isTransferedToClient(( DynamicType) entity))
{
throw new RaplaSecurityException("Entity for id " + id + " is not transferable to the client");
}
}
if ( entity instanceof Reservation)
{
entity = checkAndMakeReservationsAnonymous(sessionUser, entity);
}
if ( entity instanceof Preferences)
{
entity = removeServerOnlyPreferences((Preferences)entity);
}
security.checkRead(sessionUser, entity);
completeList.add( entity );
getLogger().debug("Get entity " + entity);
}
UpdateEvent evt = new UpdateEvent();
evt.setLastValidated(repositoryVersion);
for ( Entity entity: completeList)
{
evt.putStore(entity);
}
return new ResultImpl<UpdateEvent>( evt);
}
catch (RaplaException ex )
{
return new ResultImpl<UpdateEvent>(ex );
}
}
public FutureResult<List<ReservationImpl>> getReservations(String[] allocatableIds,Date start,Date end,Map<String,String> annotationQuery)
{
getLogger().debug ("A RemoteServer wants to reservations from ." + start + " to " + end);
try
{
checkAuthentified();
User sessionUser = getSessionUser();
User user = null;
// Reservations and appointments
ArrayList<ReservationImpl> list = new ArrayList<ReservationImpl>();
List<Allocatable> allocatables = new ArrayList<Allocatable>();
if ( allocatableIds != null )
{
for ( String id:allocatableIds)
{
Allocatable allocatable = operator.resolve(id, Allocatable.class);
security.checkRead(sessionUser, allocatable);
allocatables.add( allocatable);
}
}
ClassificationFilter[] classificationFilters = null;
Collection<Reservation> reservations = operator.getReservations(user,allocatables, start, end, classificationFilters,annotationQuery );
for (Reservation res:reservations)
{
if (isAllocatablesVisible(sessionUser, res))
{
ReservationImpl safeRes = checkAndMakeReservationsAnonymous(sessionUser, res);
list.add( safeRes);
}
}
// for (Reservation r:reservations)
// {
// Iterable<Entity>subEntities = ((ParentEntity)r).getSubEntities();
// for (Entity appointments:subEntities)
// {
// completeList.add( appointments);
// }
getLogger().debug("Get reservations " + start + " " + end + ": " + reservations.size() + "," + list.size());
return new ResultImpl<List<ReservationImpl>>(list);
}
catch (RaplaException ex )
{
return new ResultImpl<List<ReservationImpl>>(ex );
}
}
private ReservationImpl checkAndMakeReservationsAnonymous(User sessionUser,Entity entity) {
ReservationImpl reservation =(ReservationImpl) entity;
boolean canReadFromOthers = facade.canReadReservationsFromOthers(sessionUser);
boolean reservationVisible = RaplaComponent.canRead( reservation, sessionUser, canReadFromOthers);
// check if the user is allowed to read the reservation info
if ( !reservationVisible )
{
ReservationImpl clone = reservation.clone();
// we can safely change the reservation info here because we cloned it in transaction safe before
DynamicType anonymousReservationType = operator.getDynamicType( StorageOperator.ANONYMOUSEVENT_TYPE);
clone.setClassification( anonymousReservationType.newClassification());
clone.setReadOnly();
return clone;
}
else
{
return reservation;
}
}
protected boolean isAllocatablesVisible(User sessionUser, Reservation res) {
User owner = res.getOwner();
if (sessionUser.isAdmin() || owner == null || owner.equals(sessionUser) )
{
return true;
}
for (Allocatable allocatable: res.getAllocatables()) {
if (allocatable.canRead(sessionUser)) {
return true;
}
}
return true;
}
public FutureResult<VoidResult> restartServer() {
try
{
checkAuthentified();
if (!getSessionUser().isAdmin())
throw new RaplaSecurityException("Only admins can restart the server");
context.lookup(ShutdownService.class).shutdown( true);
return ResultImpl.VOID;
}
catch (RaplaException ex )
{
return new ResultImpl<VoidResult>(ex );
}
}
public FutureResult<UpdateEvent> dispatch(UpdateEvent event)
{
try
{
Date currentTimestamp = operator.getCurrentTimestamp();
Date lastSynced = event.getLastValidated();
if ( lastSynced == null)
{
throw new RaplaException("client sync time is missing");
}
if ( lastSynced.after( currentTimestamp))
{
long diff = lastSynced.getTime() - currentTimestamp.getTime();
getLogger().warn("Timestamp of client " +diff + " ms after server ");
lastSynced = currentTimestamp;
}
// LocalCache cache = operator.getCache();
// UpdateEvent event = createUpdateEvent( context,xml, cache );
User sessionUser = getSessionUser();
getLogger().info("Dispatching change for user " + sessionUser);
if ( sessionUser != null)
{
event.setUserId(sessionUser.getId());
}
dispatch_( event);
getLogger().info("Change for user " + sessionUser + " dispatched.");
UpdateEvent result = createUpdateEvent( lastSynced );
return new ResultImpl<UpdateEvent>(result );
}
catch (RaplaException ex )
{
return new ResultImpl<UpdateEvent>(ex );
}
}
public FutureResult<String> canChangePassword() {
try
{
checkAuthentified();
Boolean result = operator.canChangePassword();
return new ResultImpl<String>( result.toString());
}
catch (RaplaException ex )
{
return new ResultImpl<String>(ex );
}
}
public FutureResult<VoidResult> changePassword(String username
,String oldPassword
,String newPassword
)
{
try
{
checkAuthentified();
User sessionUser = getSessionUser();
if (!sessionUser.isAdmin()) {
if ( authenticationStore != null ) {
throw new RaplaSecurityException("Rapla can't change your password. Authentication handled by ldap plugin." );
}
operator.authenticate(username,new String(oldPassword));
}
User user = operator.getUser(username);
operator.changePassword(user,oldPassword.toCharArray(),newPassword.toCharArray());
return ResultImpl.VOID;
}
catch (RaplaException ex )
{
return new ResultImpl<VoidResult>(ex );
}
}
public FutureResult<VoidResult> changeName(String username,String newTitle,
String newSurename, String newLastname)
{
try
{
User changingUser = getSessionUser();
User user = operator.getUser(username);
if ( changingUser.isAdmin() || user.equals( changingUser) )
{
operator.changeName(user,newTitle,newSurename,newLastname);
}
else
{
throw new RaplaSecurityException("Not allowed to change email from other users");
}
return ResultImpl.VOID;
}
catch (RaplaException ex )
{
return new ResultImpl<VoidResult>(ex );
}
}
public FutureResult<VoidResult> changeEmail(String username,String newEmail)
{
try
{
User changingUser = getSessionUser();
User user = operator.getUser(username);
if ( changingUser.isAdmin() || user.equals( changingUser) )
{
operator.changeEmail(user,newEmail);
}
else
{
throw new RaplaSecurityException("Not allowed to change email from other users");
}
return ResultImpl.VOID;
}
catch (RaplaException ex )
{
return new ResultImpl<VoidResult>(ex );
}
}
public FutureResult<VoidResult> confirmEmail(String username,String newEmail)
{
try
{
User changingUser = getSessionUser();
User user = operator.getUser(username);
if ( changingUser.isAdmin() || user.equals( changingUser) )
{
String subject = getString("security_code");
Preferences prefs = operator.getPreferences( null, true );
String mailbody = "" + getString("send_code_mail_body_1") + user.getUsername() + ",\n\n"
+ getString("send_code_mail_body_2") + "\n\n" + getString("security_code") + Math.abs(user.getEmail().hashCode())
+ "\n\n" + getString("send_code_mail_body_3") + "\n\n" + "-----------------------------------------------------------------------------------"
+ "\n\n" + getString("send_code_mail_body_4") + prefs.getEntryAsString(RaplaMainContainer.TITLE, getString("rapla.title")) + " "
+ getString("send_code_mail_body_5");
final MailInterface mail = context.lookup(MailInterface.class);
final String defaultSender = prefs.getEntryAsString( MailPlugin.DEFAULT_SENDER_ENTRY, "");
mail.sendMail( defaultSender, newEmail,subject, "" + mailbody);
}
else
{
throw new RaplaSecurityException("Not allowed to change email from other users");
}
return ResultImpl.VOID;
}
catch (RaplaException ex )
{
return new ResultImpl<VoidResult>(ex );
}
}
private String getString(String key) throws RaplaException {
return getI18n().getString( key);
}
public FutureResult<List<String>> createIdentifier(String type, int count) {
try
{
RaplaType raplaType = RaplaType.find( type);
checkAuthentified();
//User user =
getSessionUser(); //check if authenified
String[] result =operator.createIdentifier(raplaType, count);
return new ResultImpl<List<String>>( Arrays.asList(result));
}
catch (RaplaException ex )
{
return new ResultImpl<List<String>>(ex );
}
}
public FutureResult<UpdateEvent> refresh(String lastSyncedTime)
{
try
{
checkAuthentified();
Date clientRepoVersion = SerializableDateTimeFormat.INSTANCE.parseTimestamp(lastSyncedTime);
UpdateEvent event = createUpdateEvent(clientRepoVersion);
return new ResultImpl<UpdateEvent>( event);
}
catch (RaplaException ex )
{
return new ResultImpl<UpdateEvent>(ex );
}
catch (ParseDateException e)
{
return new ResultImpl<UpdateEvent>(new RaplaException( e.getMessage()) );
}
}
public Logger getLogger()
{
return session.getLogger();
}
private void checkAuthentified() throws RaplaSecurityException {
if (!session.isAuthentified()) {
throw new RaplaSecurityException(RemoteStorage.USER_WAS_NOT_AUTHENTIFIED);
}
}
private User getSessionUser() throws RaplaException {
return session.getUser();
}
private void dispatch_(UpdateEvent evt) throws RaplaException {
checkAuthentified();
try {
User user;
if ( evt.getUserId() != null)
{
user = operator.resolve(evt.getUserId(), User.class);
}
else
{
user = session.getUser();
}
Collection<Entity>storeObjects = evt.getStoreObjects();
EntityStore store = new EntityStore(operator, operator.getSuperCategory());
store.addAll(storeObjects);
for (EntityReferencer references:evt.getEntityReferences( true))
{
references.setResolver( store);
}
for (Entity entity:storeObjects)
{
security.checkWritePermissions(user,entity);
}
List<PreferencePatch> preferencePatches = evt.getPreferencePatches();
for (PreferencePatch patch:preferencePatches)
{
security.checkWritePermissions(user,patch);
}
Collection<Entity>removeObjects = evt.getRemoveObjects();
for ( Entity entity:removeObjects)
{
security.checkWritePermissions(user,entity);
}
if (this.getLogger().isDebugEnabled())
this.getLogger().debug("Dispatching changes to " + operator.getClass());
operator.dispatch(evt);
if (this.getLogger().isDebugEnabled())
this.getLogger().debug("Changes dispatched returning result.");
} catch (DependencyException ex) {
throw ex;
} catch (RaplaNewVersionException ex) {
throw ex;
} catch (RaplaSecurityException ex) {
this.getLogger().warn(ex.getMessage());
throw ex;
} catch (RaplaException ex) {
this.getLogger().error(ex.getMessage(),ex);
throw ex;
} catch (Exception ex) {
this.getLogger().error(ex.getMessage(),ex);
throw new RaplaException(ex);
} catch (Error ex) {
this.getLogger().error(ex.getMessage(),ex);
throw ex;
}
}
private UpdateEvent createUpdateEvent( Date lastSynced ) throws RaplaException
{
Date currentTimestamp = operator.getCurrentTimestamp();
if ( lastSynced.after( currentTimestamp))
{
long diff = lastSynced.getTime() - currentTimestamp.getTime();
getLogger().warn("Timestamp of client " +diff + " ms after server ");
lastSynced = currentTimestamp;
}
User user = getSessionUser();
UpdateEvent safeResultEvent = new UpdateEvent();
safeResultEvent.setLastValidated( currentTimestamp);
TimeZone systemTimeZone = operator.getTimeZone();
int timezoneOffset = TimeZoneConverterImpl.getOffset( DateTools.getTimeZone(), systemTimeZone, currentTimestamp.getTime());
safeResultEvent.setTimezoneOffset( timezoneOffset );
//if ( lastSynced.before( currentTimestamp ))
{
String userId = user.getId();
TimeInterval invalidateInterval;
{
Long lastVersion = needConflictRefresh.get( userId );
if ( lastVersion != null && lastVersion > lastSynced.getTime())
{
invalidateInterval = new TimeInterval( null, null);
}
else
{
invalidateInterval = getInvalidateInterval( lastSynced.getTime() );
}
}
boolean resourceRefresh;
{
Long lastVersion = needResourceRefresh.get( userId);
resourceRefresh = ( lastVersion != null && lastVersion > lastSynced.getTime());
}
safeResultEvent.setNeedResourcesRefresh( resourceRefresh);
safeResultEvent.setInvalidateInterval( invalidateInterval);
}
if ( !safeResultEvent.isNeedResourcesRefresh())
{
Collection<Entity> updatedEntities = operator.getUpdatedEntities(lastSynced );
for ( Entity obj: updatedEntities )
{
processClientReadable( user, safeResultEvent, obj, false);
}
}
return safeResultEvent;
}
protected void processClientReadable(User user,UpdateEvent safeResultEvent, Entity obj, boolean remove) {
if ( !isTransferedToClient(obj))
{
return;
}
boolean clientStore = true;
if (user != null )
{
// we don't transmit preferences for other users
if ( obj instanceof Preferences)
{
Preferences preferences = (Preferences) obj;
User owner = preferences.getOwner();
if ( owner != null && !owner.equals( user))
{
clientStore = false;
}
else
{
obj = removeServerOnlyPreferences(preferences);
}
}
else if ( obj instanceof Allocatable)
{
Allocatable alloc = (Allocatable) obj;
if ( !alloc.canReadOnlyInformation(user))
{
clientStore = false;
}
}
else if ( obj instanceof Conflict)
{
Conflict conflict = (Conflict) obj;
if ( !ConflictImpl.canModify( conflict, user, operator) )
{
clientStore = false;
}
}
}
if ( clientStore)
{
if ( remove)
{
safeResultEvent.putRemove( obj );
}
else
{
safeResultEvent.putStore( obj );
}
}
}
// protected List<Entity>getDependentObjects(
// Appointment appointment) {
// List<Entity> toAdd = new ArrayList<Entity>();
// toAdd.add( (Entity)appointment);
// @SuppressWarnings("unchecked")
// ReservationImpl reservation = (ReservationImpl)appointment.getReservation();
// {
// toAdd.add(reservation);
// String id = reservation.getId();
// Entity inCache;
// try {
// inCache = operator.resolve( id);
// } catch (EntityNotFoundException e) {
// inCache = null;
// }
// if ( inCache != null && ((RefEntity)inCache).getVersion() > reservation.getVersion())
// {
// getLogger().error("Try to send an older version of the reservation to the client " + reservation.getName( raplaLocale.getLocale()));
// }
// for (Entity ref:reservation.getSubEntities())
// {
// toAdd.add( ref );
// }
// }
// if (!toAdd.contains(appointment))
// {
// getLogger().error(appointment.toString() + " at " + raplaLocale.formatDate(appointment.getStart()) + " does refer to reservation " + reservation.getName( raplaLocale.getLocale()) + " but the reservation does not refer back.");
// }
// return toAdd;
// }
//
private TimeInterval getInvalidateInterval( long clientRepositoryVersion)
{
TimeInterval interval = null;
synchronized (invalidateMap)
{
for ( TimeInterval current:invalidateMap.tailMap( clientRepositoryVersion).values())
{
if ( current != null)
{
interval = current.union( interval);
}
}
return interval;
}
}
public FutureResult<List<ConflictImpl>> getConflicts()
{
try
{
Set<Entity>completeList = new HashSet<Entity> ();
User sessionUser = getSessionUser();
Collection<Conflict> conflicts = operator.getConflicts( sessionUser);
List<ConflictImpl> result = new ArrayList<ConflictImpl>();
for ( Conflict conflict:conflicts)
{
result.add( (ConflictImpl) conflict);
Entity conflictRef = (Entity)conflict;
completeList.add(conflictRef);
//completeList.addAll( getDependentObjects(conflict.getAppointment1()));
//completeList.addAll( getDependentObjects(conflict.getAppointment2()));
}
//EntityList list = createList( completeList, repositoryVersion );
return new ResultImpl<List<ConflictImpl>>( result);
}
catch (RaplaException ex )
{
return new ResultImpl<List<ConflictImpl>>(ex );
}
}
@Override
public FutureResult<Date> getNextAllocatableDate( String[] allocatableIds, AppointmentImpl appointment,String[] reservationIds, Integer worktimestartMinutes, Integer worktimeendMinutes, Integer[] excludedDays, Integer rowsPerHour)
{
try
{
checkAuthentified();
List<Allocatable> allocatables = resolveAllocatables(allocatableIds);
Collection<Reservation> ignoreList = resolveReservations(reservationIds);
Date result = operator.getNextAllocatableDate(allocatables, appointment, ignoreList, worktimestartMinutes, worktimeendMinutes, excludedDays, rowsPerHour);
return new ResultImpl<Date>( result);
}
catch (RaplaException ex )
{
return new ResultImpl<Date>(ex );
}
}
@Override
public FutureResult<BindingMap> getFirstAllocatableBindings(String[] allocatableIds, List<AppointmentImpl> appointments, String[] reservationIds)
{
try
{
checkAuthentified();
//Integer[][] result = new Integer[allocatableIds.length][];
List<Allocatable> allocatables = resolveAllocatables(allocatableIds);
Collection<Reservation> ignoreList = resolveReservations(reservationIds);
List<Appointment> asList = cast(appointments);
Map<Allocatable, Collection<Appointment>> bindings = operator.getFirstAllocatableBindings(allocatables, asList, ignoreList);
Map<String,List<String>> result = new LinkedHashMap<String,List<String>>();
for ( Allocatable alloc:bindings.keySet())
{
Collection<Appointment> apps = bindings.get(alloc);
if ( apps == null)
{
apps = Collections.emptyList();
}
ArrayList<String> indexArray = new ArrayList<String>(apps.size());
for ( Appointment app: apps)
{
for (Appointment app2:appointments)
{
if (app2.equals(app ))
{
indexArray.add ( app.getId());
}
}
}
result.put(alloc.getId(), indexArray);
}
return new ResultImpl<BindingMap>(new BindingMap(result));
}
catch (RaplaException ex )
{
return new ResultImpl<BindingMap>(ex);
}
}
private List<Appointment> cast(List<AppointmentImpl> appointments) {
List<Appointment> result = new ArrayList<Appointment>(appointments.size());
for (Appointment app:appointments)
{
result.add( app);
}
return result;
}
public FutureResult<List<ReservationImpl>> getAllAllocatableBindings(String[] allocatableIds, List<AppointmentImpl> appointments, String[] reservationIds)
{
try
{
Set<ReservationImpl> result = new HashSet<ReservationImpl>();
checkAuthentified();
List<Allocatable> allocatables = resolveAllocatables(allocatableIds);
Collection<Reservation> ignoreList = resolveReservations(reservationIds);
List<Appointment> asList = cast(appointments);
Map<Allocatable, Map<Appointment, Collection<Appointment>>> bindings = operator.getAllAllocatableBindings(allocatables, asList, ignoreList);
for (Allocatable alloc:bindings.keySet())
{
Map<Appointment,Collection<Appointment>> appointmentBindings = bindings.get( alloc);
for (Appointment app: appointmentBindings.keySet())
{
Collection<Appointment> bound = appointmentBindings.get( app);
if ( bound != null)
{
for ( Appointment appointment: bound)
{
ReservationImpl reservation = (ReservationImpl) appointment.getReservation();
if ( reservation != null)
{
result.add( reservation);
}
}
}
}
}
return new ResultImpl<List<ReservationImpl>>(new ArrayList<ReservationImpl>(result));
}
catch (RaplaException ex)
{
return new ResultImpl<List<ReservationImpl>>(ex);
}
}
private List<Allocatable> resolveAllocatables(String[] allocatableIds) throws RaplaException,EntityNotFoundException, RaplaSecurityException
{
List<Allocatable> allocatables = new ArrayList<Allocatable>();
User sessionUser = getSessionUser();
for ( String id:allocatableIds)
{
Allocatable entity = operator.resolve(id, Allocatable.class);
allocatables.add( entity);
security.checkRead(sessionUser, entity);
}
return allocatables;
}
private Collection<Reservation> resolveReservations(String[] ignoreList) {
Set<Reservation> ignoreConflictsWith = new HashSet<Reservation>();
for (String reservationId: ignoreList)
{
try
{
Reservation entity = operator.resolve(reservationId, Reservation.class);
ignoreConflictsWith.add( entity);
}
catch (EntityNotFoundException ex)
{
// Do nothing reservation not found and assumed new
}
}
return ignoreConflictsWith;
}
// public void logEntityNotFound(String logMessage,String... referencedIds)
// {
// StringBuilder buf = new StringBuilder();
// buf.append("{");
// for (String id: referencedIds)
// {
// buf.append("{ id=");
// if ( id != null)
// {
// buf.append(id.toString());
// buf.append(": ");
// Entity refEntity = operator.tryResolve(id);
// if ( refEntity != null )
// {
// buf.append( refEntity.toString());
// }
// else
// {
// buf.append("NOT FOUND");
// }
// }
// else
// {
// buf.append( "is null");
// }
//
// buf.append("}, ");
// }
// buf.append("}");
// getLogger().error("EntityNotFoundFoundExceptionOnClient "+ logMessage + " " + buf.toString());
// //return ResultImpl.VOID;
// }
};
}
static public void convertToNewPluginConfig(RaplaContext context, String className, TypedComponentRole<RaplaConfiguration> newConfKey) throws RaplaContextException {
ClientFacade facade = context.lookup( ClientFacade.class);
// {
// RaplaConfiguration entry = facade.getPreferences().getEntry(RaplaComponent.PLUGIN_CONFIG,null);
// if ( entry == null )
// {
// return;
// }
// DefaultConfiguration pluginConfig = (DefaultConfiguration)entry.find("class", className);
// if ( pluginConfig == null)
// {
// return;
// }
// // only class and getEnabled
//
// }
try
{
PreferencesImpl clone = (PreferencesImpl) facade.edit( facade.getSystemPreferences());
RaplaConfiguration entry = clone.getEntry(RaplaComponent.PLUGIN_CONFIG,null);
RaplaConfiguration newPluginConfigEntry = entry.clone();
DefaultConfiguration pluginConfig = (DefaultConfiguration)newPluginConfigEntry.find("class", className);
// we split the config entry in the plugin config and the new config entry;
if ( pluginConfig != null)
{
context.lookup(Logger.class).info("Converting plugin conf " + className + " to preference entry " + newConfKey);
newPluginConfigEntry.removeChild( pluginConfig);
boolean enabled = pluginConfig.getAttributeAsBoolean("enabled", false);
RaplaConfiguration newPluginConfig = new RaplaConfiguration(pluginConfig.getName());
newPluginConfig.setAttribute("enabled", enabled);
newPluginConfig.setAttribute("class", className);
newPluginConfigEntry.addChild( newPluginConfig);
RaplaConfiguration newConfigEntry = new RaplaConfiguration( pluginConfig);
newConfigEntry.setAttribute("enabled", null);
newConfigEntry.setAttribute("class", null);
clone.putEntry(newConfKey, newConfigEntry);
clone.putEntry(RaplaComponent.PLUGIN_CONFIG, newPluginConfigEntry);
facade.store( clone);
}
}
catch (RaplaException ex)
{
if ( ex instanceof RaplaContextException)
{
throw (RaplaContextException)ex;
}
throw new RaplaContextException(ex.getMessage(),ex);
}
}
}
| Java |
package org.rapla.server.internal;
import org.rapla.entities.User;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.logger.Logger;
import org.rapla.server.RemoteSession;
/** Implementation of RemoteStorage as a RemoteService
* @see org.rapla.storage.dbrm.RemoteStorage
*/
public class RemoteSessionImpl extends RaplaComponent implements RemoteSession {
/**
*
*/
User user;
Logger logger;
// private String accessToken;
public RemoteSessionImpl(RaplaContext context, String clientName) {
super( context );
logger = super.getLogger().getChildLogger(clientName);
}
public Logger getLogger() {
return logger;
}
@Override
public User getUser() throws RaplaContextException {
if (user == null)
throw new RaplaContextException("No user found in session.");
return user;
}
@Override
public boolean isAuthentified() {
return user != null;
}
public void setUser( User user)
{
this.user = user;
}
// public void setAccessToken( String token)
// {
// this.accessToken = token;
// }
//
// @Override
// public String getAccessToken() {
// return accessToken;
// }
public void logout() {
this.setUser( null);
}
} | Java |
package org.rapla.server.internal;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Collection;
import java.util.Collections;
import org.apache.commons.codec.binary.Base64;
import org.rapla.entities.User;
import org.rapla.entities.configuration.Preferences;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.framework.TypedComponentRole;
import org.rapla.server.RaplaKeyStorage;
public class RaplaKeyStorageImpl extends RaplaComponent implements RaplaKeyStorage
{
//private static final String USER_KEYSTORE = "keystore";
private static final String ASYMMETRIC_ALGO = "RSA";
private static final TypedComponentRole<String> PUBLIC_KEY = new TypedComponentRole<String>("org.rapla.crypto.publicKey");
private static final TypedComponentRole<String> APIKEY = new TypedComponentRole<String>("org.rapla.crypto.server.refreshToken");
private static final TypedComponentRole<String> PRIVATE_KEY = new TypedComponentRole<String>("org.rapla.crypto.server.privateKey");
private String rootKey;
private String rootPublicKey;
private Base64 base64;
CryptoHandler cryptoHandler;
public String getRootKeyBase64()
{
return rootKey;
}
/**
* Initializes the Url encryption plugin.
* Checks whether an encryption key exists or not, reads an existing one from the configuration file
* or generates a new one. The decryption and encryption ciphers are also initialized here.
*
* @param context
* @param config
* @throws RaplaException
*/
public RaplaKeyStorageImpl(RaplaContext context) throws RaplaException {
super(context);
byte[] linebreake = {};
// we use an url safe encoder for the keys
this.base64 = new Base64(64, linebreake, true);
rootKey = getQuery().getSystemPreferences().getEntryAsString(PRIVATE_KEY, null);
rootPublicKey = getQuery().getSystemPreferences().getEntryAsString(PUBLIC_KEY, null);
if ( rootKey == null || rootPublicKey == null)
{
try {
generateRootKeyStorage();
} catch (NoSuchAlgorithmException e) {
throw new RaplaException( e.getMessage());
}
}
cryptoHandler = new CryptoHandler( context,rootKey);
}
public LoginInfo decrypt(String encrypted) throws RaplaException {
LoginInfo loginInfo = new LoginInfo();
String decrypt = cryptoHandler.decrypt(encrypted);
String[] split = decrypt.split(":",2);
loginInfo.login = split[0];
loginInfo.secret = split[1];
return loginInfo;
}
@Override
public void storeAPIKey(User user,String clientId, String newApiKey) throws RaplaException {
Preferences preferences = getQuery().getPreferences(user);
Preferences edit = getModification().edit( preferences);
edit.putEntry(APIKEY, newApiKey);
getModification().store( edit);
}
@Override
public Collection<String> getAPIKeys(User user) throws RaplaException {
String annotation = getQuery().getPreferences(user).getEntryAsString(APIKEY, null);
if (annotation == null)
{
return Collections.emptyList();
}
Collection<String> keyList = Collections.singleton( annotation );
return keyList;
}
@Override
public void removeAPIKey(User user, String apikey) throws RaplaException {
throw new UnsupportedOperationException();
// Allocatable key= getAllocatable(user);
// if ( key != null )
// {
// Collection<String> keyList = parseList(key.getAnnotation(APIKEY));
// if (keyList == null || !keyList.contains(apikey))
// {
// return;
// }
// key = getModification().edit( key );
// keyList.remove( apikey);
// if ( keyList.size() > 0)
// {
// key.setAnnotation(APIKEY, null);
// }
// else
// {
// key.setAnnotation(APIKEY, serialize(keyList));
// }
// // remove when no more annotations set
// if (key.getAnnotationKeys().length == 0)
// {
// getModification().remove( key);
// }
// else
// {
// getModification().store( key);
// }
// }
}
@Override
public LoginInfo getSecrets(User user, TypedComponentRole<String> tagName) throws RaplaException
{
String annotation = getQuery().getPreferences(user).getEntryAsString(tagName, null);
if ( annotation == null)
{
return null;
}
return decrypt(annotation);
}
@Override
public void storeLoginInfo(User user,TypedComponentRole<String> tagName,String login,String secret) throws RaplaException
{
Preferences preferences = getQuery().getPreferences(user);
Preferences edit = getModification().edit( preferences);
String loginPair = login +":" + secret;
String encrypted = cryptoHandler.encrypt( loginPair);
edit.putEntry(tagName, encrypted);
getModification().store( edit);
}
// public Allocatable getOrCreate(User user) throws RaplaException {
// Allocatable key= getAllocatable(user);
// if ( key == null)
// {
// DynamicType dynamicType = getQuery().getDynamicType( StorageOperator.CRYPTO_TYPE);
// Classification classification = dynamicType.newClassification();
// key = getModification().newAllocatable(classification, null );
// if ( user != null)
// {
// key.setOwner( user);
// }
// key.setClassification( classification);
// }
// else
// {
// key = getModification().edit( key);
// }
// return key;
// }
public void removeLoginInfo(User user, TypedComponentRole<String> tagName) throws RaplaException {
Preferences preferences = getQuery().getPreferences(user);
Preferences edit = getModification().edit( preferences);
edit.putEntry(tagName, null);
getModification().store( edit);
}
//
// Allocatable getAllocatable(User user) throws RaplaException
// {
// Collection<Allocatable> store = getAllocatables();
// if ( store.size() > 0)
// {
// for ( Allocatable all:store)
// {
// User owner = all.getOwner();
// if ( user == null)
// {
// if ( owner == null )
// {
// return all;
// }
// }
// else
// {
// if ( owner != null && user.equals( owner))
// {
// return all;
// }
// }
// }
// }
// return null;
// }
// public Collection<Allocatable> getAllocatables() throws RaplaException
// {
// StorageOperator operator = getClientFacade().getOperator();
// DynamicType dynamicType = operator.getDynamicType( StorageOperator.CRYPTO_TYPE);
// ClassificationFilter newClassificationFilter = dynamicType.newClassificationFilter();
// ClassificationFilter[] array = newClassificationFilter.toArray();
// Collection<Allocatable> store = operator.getAllocatables( array);
// return store;
// }
private void generateRootKeyStorage() throws NoSuchAlgorithmException, RaplaException {
getLogger().info("Generating new root key. This can take a while.");
//Classification newClassification = dynamicType.newClassification();
//newClassification.setValue("name", "root");
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance( ASYMMETRIC_ALGO );
keyPairGen.initialize( 2048);
KeyPair keyPair = keyPairGen.generateKeyPair();
getLogger().info("Root key generated");
PrivateKey privateKeyObj = keyPair.getPrivate();
this.rootKey = base64.encodeAsString(privateKeyObj.getEncoded());
PublicKey publicKeyObj = keyPair.getPublic();
this.rootPublicKey =base64.encodeAsString(publicKeyObj.getEncoded());
Preferences systemPreferences = getQuery().getSystemPreferences();
Preferences edit = getModification().edit( systemPreferences);
edit.putEntry(PRIVATE_KEY, rootKey);
edit.putEntry(PUBLIC_KEY, rootPublicKey);
getModification().store( edit);
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2013 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.server.internal;
public interface ShutdownService
{
void shutdown( boolean restart);
}
| Java |
package org.rapla.server.internal;
import java.util.Date;
import java.util.TimeZone;
import org.rapla.components.util.DateTools;
import org.rapla.server.TimeZoneConverter;
public class TimeZoneConverterImpl implements TimeZoneConverter
{
TimeZone zone;
TimeZone importExportTimeZone;
public TimeZoneConverterImpl()
{
zone = DateTools.getTimeZone();
TimeZone systemTimezone = TimeZone.getDefault();
importExportTimeZone = systemTimezone;
}
public TimeZone getImportExportTimeZone() {
return importExportTimeZone;
}
public void setImportExportTimeZone(TimeZone importExportTimeZone) {
this.importExportTimeZone = importExportTimeZone;
}
public long fromRaplaTime(TimeZone timeZone,long raplaTime)
{
long offset = TimeZoneConverterImpl.getOffset(zone,timeZone, raplaTime);
return raplaTime - offset;
}
public long toRaplaTime(TimeZone timeZone,long time)
{
long offset = TimeZoneConverterImpl.getOffset(zone,timeZone,time);
return time + offset;
}
public Date fromRaplaTime(TimeZone timeZone,Date raplaTime)
{
return new Date( fromRaplaTime(timeZone, raplaTime.getTime()));
}
public Date toRaplaTime(TimeZone timeZone,Date time)
{
return new Date( toRaplaTime(timeZone, time.getTime()));
}
public static int getOffset(TimeZone zone1,TimeZone zone2,long time) {
int offsetRapla = zone1.getOffset(time);
int offsetSystem = zone2.getOffset(time);
return offsetSystem - offsetRapla;
}
}
| Java |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Praktikum Gruppe2?, Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.server.internal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import org.rapla.components.xmlbundle.I18nBundle;
import org.rapla.entities.Category;
import org.rapla.entities.Entity;
import org.rapla.entities.Ownable;
import org.rapla.entities.RaplaType;
import org.rapla.entities.User;
import org.rapla.entities.configuration.Preferences;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Appointment;
import org.rapla.entities.domain.AppointmentFormater;
import org.rapla.entities.domain.Permission;
import org.rapla.entities.domain.Reservation;
import org.rapla.facade.ClientFacade;
import org.rapla.facade.Conflict;
import org.rapla.facade.RaplaComponent;
import org.rapla.facade.internal.FacadeImpl;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.RaplaException;
import org.rapla.framework.logger.Logger;
import org.rapla.storage.CachableStorageOperator;
import org.rapla.storage.PreferencePatch;
import org.rapla.storage.RaplaSecurityException;
/** checks if the client can store or delete an entity */
public class SecurityManager
{
I18nBundle i18n;
AppointmentFormater appointmentFormater;
CachableStorageOperator operator;
RaplaContext context;
Logger logger;
public SecurityManager(RaplaContext context) throws RaplaException {
logger = context.lookup( Logger.class);
operator = context.lookup( CachableStorageOperator.class);
i18n = context.lookup(RaplaComponent.RAPLA_RESOURCES);
appointmentFormater = context.lookup(AppointmentFormater.class);
this.context = context;
}
void checkWritePermissions(User user,Entity entity) throws RaplaSecurityException {
if (user.isAdmin())
return;
Object id = entity.getId();
if (id == null)
throw new RaplaSecurityException("No id set");
boolean permitted = false;
@SuppressWarnings("unchecked")
Class<Entity> typeClass = entity.getRaplaType().getTypeClass();
Entity original = operator.tryResolve( entity.getId(), typeClass);
// flag indicates if a user only exchanges allocatables (needs to have admin-access on the allocatable)
boolean canExchange = false;
boolean ownable = entity instanceof Ownable;
if (ownable || entity instanceof Appointment) {
User entityOwner;
if ( ownable)
{
entityOwner = ((Ownable) entity).getOwner();
}
else
{
entityOwner = ((Appointment) entity).getOwner();
}
if (original == null) {
permitted = entityOwner != null && user.isIdentical(entityOwner);
if (getLogger().isDebugEnabled())
getLogger().debug("Permissions for new object " + entity
+ "\nUser check: " + user + " = " + entityOwner);
} else {
User originalOwner;
if ( ownable)
{
originalOwner = ((Ownable) original).getOwner();
}
else
{
originalOwner = ((Appointment) original).getOwner();
}
if (getLogger().isDebugEnabled())
getLogger().debug("Permissions for existing object " + entity
+ "\nUser check: " + user + " = " + entityOwner + " = " + originalOwner);
permitted = (originalOwner != null) && originalOwner.isIdentical(user) && originalOwner.isIdentical(entityOwner);
if ( !permitted ) {
canExchange = canExchange( user, entity, original );
permitted = canExchange;
}
}
}
if ( !permitted && entity instanceof Allocatable ){
if ( original == null ) {
permitted = isRegisterer(user);
} else {
permitted = ((Allocatable)original).canModify( user );
}
}
if ( !permitted && original != null)
{
permitted = RaplaComponent.checkClassifiableModifyPermissions(original, user);
}
if (!permitted && entity instanceof Appointment)
{
final Reservation reservation = ((Appointment)entity).getReservation();
Reservation originalReservation = operator.tryResolve(reservation.getId(), Reservation.class);
if ( originalReservation != null)
{
permitted = RaplaComponent.checkClassifiableModifyPermissions(originalReservation, user);
}
}
if (!permitted)
throw new RaplaSecurityException(i18n.format("error.modify_not_allowed", new Object []{ user.toString(),entity.toString()}));
// Check if the user can change the reservation
if ( Reservation.TYPE ==entity.getRaplaType() )
{
Reservation reservation = (Reservation) entity ;
Reservation originalReservation = (Reservation)original;
Allocatable[] all = reservation.getAllocatables();
if ( originalReservation != null && canExchange ) {
List<Allocatable> newAllocatabes = new ArrayList<Allocatable>( Arrays.asList(reservation.getAllocatables() ) );
newAllocatabes.removeAll( Arrays.asList( originalReservation.getAllocatables()));
all = newAllocatabes.toArray( Allocatable.ALLOCATABLE_ARRAY);
}
if ( originalReservation == null)
{
Category group = getUserGroupsCategory().getCategory( Permission.GROUP_CAN_CREATE_EVENTS);
if (group != null && !user.belongsTo(group))
{
throw new RaplaSecurityException(i18n.format("error.create_not_allowed", new Object []{ user.toString(),entity.toString()}));
}
}
checkPermissions( user, reservation, originalReservation , all);
}
}
private Logger getLogger()
{
return logger;
}
protected boolean isRegisterer(User user) throws RaplaSecurityException {
try {
Category registererGroup = getUserGroupsCategory().getCategory(Permission.GROUP_REGISTERER_KEY);
return user.belongsTo(registererGroup);
} catch (RaplaException ex) {
throw new RaplaSecurityException(ex );
}
}
public Category getUserGroupsCategory() throws RaplaSecurityException {
Category userGroups = operator.getSuperCategory().getCategory(Permission.GROUP_CATEGORY_KEY);
if ( userGroups == null) {
throw new RaplaSecurityException("No category '" + Permission.GROUP_CATEGORY_KEY + "' available");
}
return userGroups;
}
/** checks if the user just exchanges one allocatable or removes one. The user needs admin-access on the
* removed allocatable and the newly inserted allocatable */
private boolean canExchange(User user,Entity entity,Entity original) {
if ( Appointment.TYPE.equals( entity.getRaplaType() )) {
return ((Appointment) entity).matches( (Appointment) original );
} if ( Reservation.TYPE.equals( entity.getRaplaType() )) {
Reservation newReservation = (Reservation) entity;
Reservation oldReservation = (Reservation) original;
// We only need to check the length because we compare the appointments above.
if ( newReservation.getAppointments().length != oldReservation.getAppointments().length )
{
return false;
}
List<Allocatable> oldAllocatables = Arrays.asList(oldReservation.getAllocatables());
List<Allocatable> newAllocatables = Arrays.asList(newReservation.getAllocatables());
List<Allocatable> inserted = new ArrayList<Allocatable>(newAllocatables);
List<Allocatable> removed = new ArrayList<Allocatable>(oldAllocatables);
List<Allocatable> overlap = new ArrayList<Allocatable>(oldAllocatables);
inserted.removeAll( oldAllocatables );
removed.removeAll( newAllocatables );
overlap.retainAll( inserted );
if ( inserted.size() == 0 && removed.size() == 0)
{
return false;
}
// he must have admin rights on all inserted resources
Iterator<Allocatable> it = inserted.iterator();
while (it.hasNext()) {
if (!canAllocateForOthers(it.next(),user))
{
return false;
}
}
// and he must have admin rights on all the removed resources
it = removed.iterator();
while (it.hasNext()) {
if (!canAllocateForOthers(it.next(),user))
{
return false;
}
}
// He can't change appointments, only exchange allocatables he has admin-priviliges for
it = overlap.iterator();
while (it.hasNext()) {
Allocatable all = it.next();
Appointment[] r1 = newReservation.getRestriction( all );
Appointment[] r2 = oldReservation.getRestriction( all );
boolean changed = false;
if ( r1.length != r2.length ) {
changed = true;
} else {
for ( int i=0; i< r1.length; i++ ) {
if ( !r1[i].matches(r2[i]) ) {
changed = true;
}
}
}
if ( changed && !canAllocateForOthers( all, user )) {
return false;
}
}
return true;
}
return false;
}
/** for Thierry, we can make this configurable in the next version */
private boolean canAllocateForOthers(Allocatable allocatable, User user) {
// only admins, current behaviour
return allocatable.canModify( user);
// everyone who can allocate the resource anytime
//return allocatable.canAllocate( user, null, null, operator.today());
// everyone
//return true;
}
private void checkConflictsAllowed(User user, Allocatable allocatable, Conflict[] conflictsBefore, Conflict[] conflictsAfter) throws RaplaSecurityException {
int nConflictsBefore = 0;
int nConflictsAfter = 0;
if ( allocatable.canCreateConflicts( user ) ) {
return;
}
if ( conflictsBefore != null ) {
for ( int i = 0; i < conflictsBefore.length; i++ ) {
if ( conflictsBefore[i].getAllocatable().equals ( allocatable ) ) {
nConflictsBefore ++;
}
}
}
for ( int i = 0; i < conflictsAfter.length; i++ ) {
if ( conflictsAfter[i].getAllocatable().equals ( allocatable ) ) {
nConflictsAfter ++;
}
}
if ( nConflictsAfter > nConflictsBefore ) {
String all = allocatable.getName( i18n.getLocale() );
throw new RaplaSecurityException( i18n.format("warning.no_conflict_permission", all ) );
}
}
private void checkPermissions( User user, Reservation r, Reservation original, Allocatable[] allocatables ) throws RaplaSecurityException {
ClientFacade facade;
try {
facade = context.lookup(ClientFacade.class);
} catch (RaplaContextException e) {
throw new RaplaSecurityException(e.getMessage(), e);
}
Conflict[] conflictsBefore = null;
Conflict[] conflictsAfter = null;
try {
conflictsAfter = facade.getConflicts( r );
if ( original != null ) {
conflictsBefore = facade.getConflicts( original );
}
} catch ( RaplaException ex ) {
throw new RaplaSecurityException(" Can't check permissions due to:" + ex.getMessage(), ex );
}
Appointment[] appointments = r.getAppointments();
// ceck if the user has the permisson to add allocations in the given time
for (int i = 0; i < allocatables.length; i++ ) {
Allocatable allocatable = allocatables[i];
checkConflictsAllowed( user, allocatable, conflictsBefore, conflictsAfter );
for (int j = 0; j < appointments.length; j++ ) {
Appointment appointment = appointments[j];
Date today = operator.today();
if ( r.hasAllocated( allocatable, appointment ) &&
!FacadeImpl.hasPermissionToAllocate( user, appointment, allocatable, original,today ) ) {
String all = allocatable.getName( i18n.getLocale() );
String app = appointmentFormater.getSummary( appointment );
String error = i18n.format("warning.no_reserve_permission"
,all
,app);
throw new RaplaSecurityException( error );
}
}
}
if (original == null )
return;
Date today = operator.today();
// 1. calculate the deleted assignments from allocatable to appointments
// 2. check if they were allowed to change in the specified time
appointments = original.getAppointments();
allocatables = original.getAllocatables();
for (int i = 0; i < allocatables.length; i++ ) {
Allocatable allocatable = allocatables[i];
for (int j = 0; j < appointments.length; j++ ) {
Appointment appointment = appointments[j];
if ( original.hasAllocated( allocatable, appointment )
&& !r.hasAllocated( allocatable, appointment ) ) {
Date start = appointment.getStart();
Date end = appointment.getMaxEnd();
if ( !allocatable.canAllocate( user, start, end, today ) ) {
String all = allocatable.getName( i18n.getLocale() );
String app = appointmentFormater.getSummary( appointment );
String error = i18n.format("warning.no_reserve_permission"
,all
,app);
throw new RaplaSecurityException( error );
}
}
}
}
}
public void checkRead(User user,Entity entity) throws RaplaSecurityException, RaplaException {
RaplaType<?> raplaType = entity.getRaplaType();
if ( raplaType == Allocatable.TYPE)
{
Allocatable allocatable = (Allocatable) entity;
if ( !allocatable.canReadOnlyInformation( user))
{
throw new RaplaSecurityException(i18n.format("error.read_not_allowed",user, allocatable.getName( null)));
}
}
if ( raplaType == Preferences.TYPE)
{
Ownable ownable = (Preferences) entity;
User owner = ownable.getOwner();
if ( user != null && !user.isAdmin() && (owner == null || !user.equals( owner)))
{
throw new RaplaSecurityException(i18n.format("error.read_not_allowed", user, entity));
}
}
}
public void checkWritePermissions(User user, PreferencePatch patch) throws RaplaSecurityException
{
String ownerId = patch.getUserId();
if ( user != null && !user.isAdmin() && (ownerId == null || !user.getId().equals( ownerId)))
{
throw new RaplaSecurityException("User " + user + " can't modify preferences " + ownerId);
}
}
}
| Java |
package org.rapla.server.internal;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
public class CryptoHandler extends RaplaComponent {
String syncEncryptionAlg = "AES/ECB/PKCS5Padding";
private Cipher encryptionCipher;
private Cipher decryptionCipher;
private Base64 base64;
private static final String ENCODING = "UTF-8";
public CryptoHandler( RaplaContext context,String pepper) throws RaplaException
{
super( context);
try {
byte[] linebreake = {};
this.base64 = new Base64(64, linebreake, true);
initializeCiphers( pepper);
} catch (Exception e) {
throw new RaplaException( e.getMessage(),e);
}
}
private void initializeCiphers(String pepper) throws InvalidKeyException, UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException {
byte[] key = pepper.getBytes("UTF-8");
MessageDigest sha = MessageDigest.getInstance("SHA-1");
key = sha.digest(key);
key = Arrays.copyOf(key, 16); // use only first 128 bit
Key specKey = new SecretKeySpec(key, "AES");
this.encryptionCipher = Cipher.getInstance(syncEncryptionAlg);
this.encryptionCipher.init(Cipher.ENCRYPT_MODE, specKey);
this.decryptionCipher = Cipher.getInstance(syncEncryptionAlg);
this.decryptionCipher.init(Cipher.DECRYPT_MODE, specKey);
}
public String encrypt(String toBeEncrypted) throws RaplaException{
try {
return base64.encodeToString(this.encryptionCipher.doFinal(toBeEncrypted.getBytes(ENCODING)));
} catch (Exception e) {
throw new RaplaException(e.getMessage(), e);
}
}
public String decrypt(String toBeDecryptedBase64) throws RaplaException{
try {
return new String(this.decryptionCipher.doFinal(base64.decode(toBeDecryptedBase64.getBytes(ENCODING))));
} catch (Exception e) {
throw new RaplaException(e.getMessage(), e);
}
}
}
| Java |
package org.rapla.rest.client;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.zip.GZIPInputStream;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonParser;
public class HTTPJsonConnector {
public HTTPJsonConnector() {
super();
}
private String readResultToString(InputStream input) throws IOException {
InputStreamReader in = new InputStreamReader( input,"UTF-8");
char[] buf = new char[4096];
StringBuffer buffer = new StringBuffer();
while ( true )
{
int len = in.read(buf);
if ( len == -1)
{
break;
}
buffer.append( buf, 0,len );
}
String result = buffer.toString();
in.close();
return result;
}
public JsonObject sendPost(URL methodURL, JsonElement jsonObject, String authenticationToken) throws IOException,JsonParseException {
return sendCall("POST", methodURL, jsonObject, authenticationToken);
}
public JsonObject sendGet(URL methodURL, String authenticationToken) throws IOException,JsonParseException {
return sendCall("GET", methodURL, null, authenticationToken);
}
public JsonObject sendPut(URL methodURL, JsonElement jsonObject, String authenticationToken) throws IOException,JsonParseException {
return sendCall("PUT", methodURL, jsonObject, authenticationToken);
}
public JsonObject sendPatch(URL methodURL, JsonElement jsonObject, String authenticationToken) throws IOException,JsonParseException {
return sendCall("PATCH", methodURL, jsonObject, authenticationToken);
}
public JsonObject sendDelete(URL methodURL, String authenticationToken) throws IOException,JsonParseException {
return sendCall("DELETE", methodURL, null, authenticationToken);
}
protected JsonObject sendCall(String requestMethod, URL methodURL, JsonElement jsonObject, String authenticationToken) throws IOException,JsonParseException {
HttpURLConnection conn = (HttpURLConnection)methodURL.openConnection();
if ( !requestMethod.equals("POST") && !requestMethod.equals("GET"))
{
conn.setRequestMethod("POST");
// we tunnel all non POST or GET requests to avoid proxy filtering (e.g. URLConnection does not allow PATCH)
conn.setRequestProperty("X-HTTP-Method-Override",requestMethod);
}
else
{
conn.setRequestMethod(requestMethod);
}
conn.setUseCaches( false );
conn.setRequestProperty("Accept-Encoding", "gzip, deflate");
conn.setRequestProperty("Content-Type", "application/json" + ";charset=utf-8");
conn.setRequestProperty("Accept", "application/json");
if ( authenticationToken != null)
{
conn.setRequestProperty("Authorization", "Bearer " + authenticationToken);
}
conn.setReadTimeout(20000); //set timeout to 20 seconds
conn.setConnectTimeout(15000); //set connect timeout to 15 seconds
conn.setDoOutput(true);
conn.connect();
if ( requestMethod.equals("PUT") ||requestMethod.equals("POST") ||requestMethod.equals("PATCH"))
{
OutputStream outputStream = null;
Writer wr = null;
try
{
outputStream= conn.getOutputStream();
wr = new OutputStreamWriter(outputStream,"UTF-8");
Gson gson = new GsonBuilder().create();
String body = gson.toJson( jsonObject);
wr.write( body);
wr.flush();
}
finally
{
if ( wr != null)
{
wr.close();
}
if ( outputStream != null)
{
outputStream.close();
}
}
}
else
{
}
JsonObject resultMessage = readResult(conn);
return resultMessage;
}
public JsonObject readResult(HttpURLConnection conn) throws IOException,JsonParseException {
String resultString;
InputStream inputStream = null;
try
{
String encoding = conn.getContentEncoding();
if (encoding != null && encoding.equalsIgnoreCase("gzip"))
{
inputStream = new GZIPInputStream(conn.getInputStream());
}
else if (encoding != null && encoding.equalsIgnoreCase("deflate")) {
inputStream = new InflaterInputStream(conn.getInputStream(), new Inflater(true));
}
else {
inputStream = conn.getInputStream();
}
resultString = readResultToString( inputStream);
}
finally
{
if ( inputStream != null)
{
inputStream.close();
}
}
JsonParser jsonParser = new JsonParser();
JsonElement parsed = jsonParser.parse(resultString);
if ( !(parsed instanceof JsonObject))
{
throw new JsonParseException("Invalid json result. JsonObject expected.");
}
JsonObject resultMessage = (JsonObject) parsed;
return resultMessage;
}
} | Java |
package org.rapla.rest.jsonpatch.mergepatch.server;
public class JsonPatchException extends Exception {
private static final long serialVersionUID = 1L;
public JsonPatchException(String string) {
super(string);
}
}
| Java |
/*
* Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
*
* This software is dual-licensed under:
*
* - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
* later version;
* - the Apache Software License (ASL) version 2.0.
*
* The text of both licenses is available under the src/resources/ directory of
* this project (under the names LGPL-3.0.txt and ASL-2.0.txt respectively).
*
* Direct link to the sources:
*
* - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
* - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package org.rapla.rest.jsonpatch.mergepatch.server;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
/**
* Merge patch for a JSON Object
*
* <p>This only takes care of the top level, and delegates to other {@link
* JsonMergePatch} instances for deeper levels.</p>
*/
final class ObjectMergePatch
extends JsonMergePatch
{
private final Map<String, JsonElement> fields;
private final Set<String> removals;
ObjectMergePatch(final JsonElement content)
{
super(content);
fields = asMap(content);
removals = new HashSet<String>();
for (final Map.Entry<String, JsonElement> entry: fields.entrySet())
if (entry.getValue() == null)
removals.add(entry.getKey());
fields.keySet().removeAll(removals);
}
@Override
public JsonElement apply(final JsonElement input) throws JsonPatchException
{
if (!input.isJsonObject())
return mapToNode(fields);
final Map<String, JsonElement> map = asMap(input);
// Remove all entries which must be removed
map.keySet().removeAll(removals);
// Now cycle through what is left
String memberName;
JsonElement patchNode;
for (final Map.Entry<String, JsonElement> entry: map.entrySet()) {
memberName = entry.getKey();
patchNode = fields.get(memberName);
// Leave untouched if no mention in the patch
if (patchNode == null)
continue;
// If the patch node is a primitive type, replace in the result.
// Reminder: there cannot be a JSON null anymore
if (patchNode.isJsonPrimitive()) {
entry.setValue(patchNode); // no need for .deepCopy()
continue;
}
final JsonMergePatch patch = JsonMergePatch.fromJson(patchNode);
entry.setValue(patch.apply(entry.getValue()));
}
// Finally, if there are members in the patch not present in the input,
// fill in members
for (final String key: difference(fields.keySet(), map.keySet()))
map.put(key, clearNulls(fields.get(key)));
return mapToNode(map);
}
private Set<String> difference(Set<String> keySet, Set<String> keySet2) {
LinkedHashSet<String> result = new LinkedHashSet<String>();
for ( String key:keySet)
{
if ( !keySet2.contains(key))
{
result.add( key);
}
}
return result;
}
private Map<String, JsonElement> asMap(JsonElement input) {
Map<String,JsonElement> result = new LinkedHashMap<String,JsonElement>();
for ( Entry<String, JsonElement> entry :input.getAsJsonObject().entrySet())
{
JsonElement value = entry.getValue();
String key = entry.getKey();
result.put( key,value);
}
return result;
}
private static JsonElement mapToNode(final Map<String, JsonElement> map)
{
final JsonObject ret = new JsonObject();
for ( String key: map.keySet())
{
JsonElement value = map.get( key);
ret.add(key, value);
}
return ret;
}
}
| Java |
package org.rapla.rest.jsonpatch.mergepatch.server;
import java.util.Iterator;
import java.util.Map;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
public abstract class JsonMergePatch
{
protected final JsonElement origPatch;
/**
* Protected constructor
*
* <p>Only necessary for serialization purposes. The patching process
* itself never requires the full node to operate.</p>
*
* @param node the original patch node
*/
protected JsonMergePatch(final JsonElement node)
{
origPatch = node;
}
public abstract JsonElement apply(final JsonElement input) throws JsonPatchException;
public static JsonMergePatch fromJson(final JsonElement input)
throws JsonPatchException
{
if ( input.isJsonPrimitive())
{
throw new JsonPatchException("Only json containers are supported");
}
return input.isJsonArray() ? new ArrayMergePatch(input)
: new ObjectMergePatch(input);
}
/**
* Clear "null values" from a JSON value
*
* <p>Non container values are unchanged. For arrays, null elements are
* removed. From objects, members whose values are null are removed.</p>
*
* <p>This method is recursive, therefore arrays within objects, or objects
* within arrays, or arrays within arrays etc are also affected.</p>
*
* @param node the original JSON value
* @return a JSON value without null values (see description)
*/
protected static JsonElement clearNulls(final JsonElement node)
{
if (node.isJsonPrimitive())
return node;
return node.isJsonArray() ? clearNullsFromArray((JsonArray)node) : clearNullsFromObject((JsonObject)node);
}
private static JsonElement clearNullsFromArray(final JsonArray node)
{
final JsonArray ret = new JsonArray();
/*
* Cycle through array elements. If the element is a null node itself,
* skip it. Otherwise, add a "cleaned up" element to the result.
*/
for (final JsonElement element: node)
if (!element.isJsonNull())
ret.add(clearNulls(element));
return ret;
}
private static JsonElement clearNullsFromObject(final JsonObject node)
{
final JsonObject ret = new JsonObject();
final Iterator<Map.Entry<String, JsonElement>> iterator
= node.entrySet().iterator();
Map.Entry<String, JsonElement> entry;
JsonElement value;
/*
* When faces with an object, cycle through this object's entries.
*
* If the value of the entry is a JSON null, don't include it in the
* result. If not, include a "cleaned up" value for this key instead of
* the original element.
*/
while (iterator.hasNext()) {
entry = iterator.next();
value = entry.getValue();
if (value != null) {
String key = entry.getKey();
JsonElement clearNulls = clearNulls(value);
ret.add(key, clearNulls);
}
}
return ret;
}
public String toString()
{
return origPatch.toString();
}
} | Java |
package org.rapla.rest.jsonpatch.mergepatch.server;
import com.google.gson.JsonElement;
final class ArrayMergePatch extends JsonMergePatch
{
// Always an array
private final JsonElement content;
ArrayMergePatch(final JsonElement content)
{
super(content);
this.content = clearNulls(content);
}
@Override
public JsonElement apply(final JsonElement input) throws JsonPatchException
{
return content;
}
} | Java |
package org.rapla.rest;
public @interface GwtIncompatible {
}
| Java |
package org.rapla.rest.server;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import javax.jws.WebParam;
import javax.jws.WebService;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Appointment;
import org.rapla.entities.domain.Reservation;
import org.rapla.entities.domain.internal.AppointmentImpl;
import org.rapla.entities.domain.internal.ReservationImpl;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.entities.dynamictype.DynamicTypeAnnotations;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.servletpages.RaplaPageGenerator;
import org.rapla.storage.RaplaSecurityException;
@WebService
public class RaplaEventsRestPage extends AbstractRestPage implements RaplaPageGenerator
{
public RaplaEventsRestPage(RaplaContext context) throws RaplaException
{
super(context);
}
private Collection<String> CLASSIFICATION_TYPES = Arrays.asList(new String[] {DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESERVATION});
public List<ReservationImpl> list(@WebParam(name="user") User user, @WebParam(name="start")Date start, @WebParam(name="end")Date end, @WebParam(name="resources") List<String> resources, @WebParam(name="eventTypes") List<String> eventTypes,@WebParam(name="attributeFilter") Map<String,String> simpleFilter ) throws RaplaException
{
Collection<Allocatable> allocatables = new ArrayList<Allocatable>();
for (String id :resources)
{
Allocatable allocatable = operator.resolve(id, Allocatable.class);
allocatables.add( allocatable);
}
ClassificationFilter[] filters = getClassificationFilter(simpleFilter, CLASSIFICATION_TYPES, eventTypes);
Map<String, String> annotationQuery = null;
boolean canReadReservationsFromOthers = getQuery().canReadReservationsFromOthers(user);
User owner = null;
Collection<Reservation> reservations = operator.getReservations(owner, allocatables, start, end, filters, annotationQuery);
List<ReservationImpl> result = new ArrayList<ReservationImpl>();
for ( Reservation r:reservations)
{
if ( RaplaComponent.canRead(r, user, canReadReservationsFromOthers))
{
result.add((ReservationImpl) r);
}
}
return result;
}
public ReservationImpl get(@WebParam(name="user") User user, @WebParam(name="id")String id) throws RaplaException
{
ReservationImpl event = (ReservationImpl) operator.resolve(id, Reservation.class);
boolean canReadReservationsFromOthers = getQuery().canReadReservationsFromOthers(user);
if (!RaplaComponent.canRead(event, user, canReadReservationsFromOthers))
{
throw new RaplaSecurityException("User " + user + " can't read event " + event);
}
return event;
}
public ReservationImpl update(@WebParam(name="user") User user, ReservationImpl event) throws RaplaException
{
if (!RaplaComponent.canModify(event, user))
{
throw new RaplaSecurityException("User " + user + " can't modify event " + event);
}
event.setResolver( operator);
getModification().store( event);
ReservationImpl result =(ReservationImpl) getModification().getPersistant( event);
return result;
}
public ReservationImpl create(@WebParam(name="user") User user, ReservationImpl event) throws RaplaException
{
if (!getQuery().canCreateReservations(user))
{
throw new RaplaSecurityException("User " + user + " can't modify event " + event);
}
if (event.getId() != null)
{
throw new RaplaException("Id has to be null for new events");
}
String eventId = operator.createIdentifier(Reservation.TYPE, 1)[0];
event.setId( eventId);
event.setResolver( operator);
event.setCreateDate( operator.getCurrentTimestamp());
Appointment[] appointments = event.getAppointments();
String[] appointmentIds = operator.createIdentifier(Appointment.TYPE, 1);
for ( int i=0;i<appointments.length;i++)
{
AppointmentImpl app = (AppointmentImpl)appointments[i];
String id = appointmentIds[i];
app.setId(id);
}
event.setOwner( user );
getModification().store( event);
ReservationImpl result =(ReservationImpl) getModification().getPersistant( event);
return result;
}
}
| Java |
package org.rapla.rest.server;
import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.rapla.entities.User;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.entities.dynamictype.DynamicTypeAnnotations;
import org.rapla.facade.ClientFacade;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.rest.gwtjsonrpc.server.JsonServlet;
import org.rapla.server.ServerServiceContainer;
import org.rapla.servletpages.RaplaPageGenerator;
import org.rapla.storage.RaplaSecurityException;
import org.rapla.storage.StorageOperator;
public class AbstractRestPage extends RaplaComponent implements RaplaPageGenerator {
protected StorageOperator operator;
protected JsonServlet servlet;
protected final ServerServiceContainer serverContainer;
String getMethod = null;
String updatetMethod = null;
String listMethod = null;
String createMethod = null;
public AbstractRestPage(RaplaContext context) throws RaplaException
{
super(context);
operator = context.lookup( ClientFacade.class).getOperator();
serverContainer = context.lookup(ServerServiceContainer.class);
Class class1 = getServiceObject().getClass();
Collection<String> publicMethodNames = getPublicMethods(class1);
servlet = new JsonServlet(getLogger(), class1);
if ( publicMethodNames.contains("get"))
{
getMethod = "get";
}
if ( publicMethodNames.contains("update"))
{
updatetMethod = "update";
}
if ( publicMethodNames.contains("create"))
{
createMethod = "create";
}
if ( publicMethodNames.contains("list"))
{
listMethod = "list";
}
}
@Override
public void generatePage(ServletContext servletContext, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
User user;
Object serviceObj = getServiceObject();
try {
user = serverContainer.getUser(request);
if ( user == null)
{
throw new RaplaSecurityException("User not authentified. Pass access token");
}
request.setAttribute("user", user);
String pathInfo = request.getPathInfo();
int appendix = pathInfo.indexOf("/",1);
String method = request.getMethod();
if ( appendix > 0)
{
if ( method.equals("GET") && getMethod != null )
{
String id = pathInfo.substring(appendix+1);
request.setAttribute("id", id);
request.setAttribute("method", getMethod);
}
else if ( method.equals("PATCH") && getMethod != null && updatetMethod != null)
{
String id = pathInfo.substring(appendix+1);
request.setAttribute("id", id);
request.setAttribute("method", getMethod);
request.setAttribute("patchMethod", updatetMethod);
}
else if ( method.equals("PUT") && updatetMethod != null)
{
String id = pathInfo.substring(appendix+1);
request.setAttribute("id", id);
request.setAttribute("method", updatetMethod);
}
else
{
throw new RaplaException(method + " Method not supported in this context");
}
}
else
{
if ( method.equals("GET") && listMethod != null)
{
request.setAttribute("method", listMethod);
}
else if ( method.equals("POST") && createMethod != null)
{
request.setAttribute("method", createMethod);
}
else
{
throw new RaplaException(method + " Method not supported in this context");
}
}
} catch (RaplaException ex) {
servlet.serviceError(request, response, servletContext, ex);
return;
}
servlet.service(request, response, servletContext, serviceObj);
// super.generatePage(servletContext, request, response);
}
protected Collection<String> getPublicMethods(Class class1) {
HashSet<String> result = new HashSet<String>();
for (Method m:class1.getMethods())
{
if ( Modifier.isPublic(m.getModifiers() ))
{
result.add( m.getName());
}
}
return result;
}
public ClassificationFilter[] getClassificationFilter(Map<String, String> simpleFilter, Collection<String> selectedClassificationTypes, Collection<String> typeNames) throws RaplaException {
ClassificationFilter[] filters = null;
if ( simpleFilter != null || typeNames == null)
{
DynamicType[] types = getQuery().getDynamicTypes(null);
List<ClassificationFilter> filterList = new ArrayList<ClassificationFilter>();
for ( DynamicType type:types)
{
String classificationType = type.getAnnotation(DynamicTypeAnnotations.KEY_CLASSIFICATION_TYPE);
if ( classificationType == null || !selectedClassificationTypes.contains(classificationType))
{
continue;
}
ClassificationFilter classificationFilter = type.newClassificationFilter();
if ( typeNames != null)
{
if ( !typeNames.contains( type.getKey()))
{
continue;
}
}
if ( simpleFilter != null)
{
for (String key:simpleFilter.keySet())
{
Attribute att = type.getAttribute(key);
if ( att != null)
{
String value = simpleFilter.get(key);
// convert from string to attribute type
Object object = att.convertValue(value);
if ( object != null)
{
classificationFilter.addEqualsRule(att.getKey(), object);
}
filterList.add(classificationFilter);
}
}
}
else
{
filterList.add(classificationFilter);
}
}
filters = filterList.toArray( new ClassificationFilter[] {});
}
return filters;
}
private Object getServiceObject() {
return this;
}
} | Java |
package org.rapla.rest.server;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.RaplaException;
import org.rapla.rest.gwtjsonrpc.common.JSONParserWrapper;
import org.rapla.rest.gwtjsonrpc.server.JsonServlet;
import org.rapla.rest.gwtjsonrpc.server.RPCServletUtils;
import org.rapla.server.ServerServiceContainer;
import org.rapla.servletpages.RaplaPageGenerator;
import org.rapla.storage.RaplaSecurityException;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
public class RaplaAPIPage extends RaplaComponent implements RaplaPageGenerator
{
final ServerServiceContainer serverContainer;
public RaplaAPIPage(RaplaContext context) throws RaplaContextException {
super(context);
serverContainer = context.lookup(ServerServiceContainer.class);
}
Map<String,JsonServlet> servletMap = new HashMap<String, JsonServlet>();
private JsonServlet getJsonServlet(HttpServletRequest request,String serviceAndMethodName) throws RaplaException {
if ( serviceAndMethodName == null || serviceAndMethodName.length() == 0) {
throw new RaplaException("Servicename missing in url");
}
int indexRole = serviceAndMethodName.indexOf( "/" );
String interfaceName;
if ( indexRole > 0 )
{
interfaceName= serviceAndMethodName.substring( 0, indexRole );
if ( serviceAndMethodName.length() >= interfaceName.length())
{
String methodName = serviceAndMethodName.substring( indexRole + 1 );
request.setAttribute(JsonServlet.JSON_METHOD, methodName);
}
}
else
{
interfaceName = serviceAndMethodName;
}
JsonServlet servlet = servletMap.get( interfaceName);
if ( servlet == null)
{
try
{
if (!serverContainer.hasWebservice(interfaceName))
{
throw new RaplaException("Webservice " + interfaceName + " not configured or initialized.");
}
Class<?> interfaceClass = Class.forName(interfaceName, true,RaplaAPIPage.class.getClassLoader());
// Test if service is found
servlet = new JsonServlet(getLogger(), interfaceClass);
}
catch (Exception ex)
{
throw new RaplaException( ex.getMessage(), ex);
}
servletMap.put( interfaceName, servlet);
}
return servlet;
}
public void generatePage(ServletContext servletContext, HttpServletRequest request, HttpServletResponse response ) throws IOException, ServletException
{
String id = request.getParameter("id");
String serviceAndMethodName = getServiceAndMethodName(request);
try
{
JsonServlet servlet;
try
{
servlet = getJsonServlet( request, serviceAndMethodName );
}
catch (RaplaException ex)
{
getLogger().error(ex.getMessage(), ex);
String out = serializeException(id, ex);
RPCServletUtils.writeResponse(servletContext, response, out, false);
return;
}
Class<?> role = servlet.getInterfaceClass();
Object impl;
try
{
impl = serverContainer.createWebservice(role, request);
}
catch (RaplaSecurityException ex)
{
servlet.serviceError(request, response, servletContext, ex);
return;
}
servlet.service(request, response, servletContext, impl);
}
catch ( RaplaSecurityException ex)
{
getLogger().error(ex.getMessage());
}
catch ( RaplaException ex)
{
getLogger().error(ex.getMessage(), ex);
}
}
protected String getServiceAndMethodName(HttpServletRequest request) {
String requestURI =request.getPathInfo();
String path = "/json/";
int rpcIndex=requestURI.indexOf(path) ;
String serviceAndMethodName = requestURI.substring(rpcIndex + path.length()).trim();
return serviceAndMethodName;
}
protected String serializeException(String id, Exception ex)
{
final JsonObject r = new JsonObject();
String versionName = "jsonrpc";
int code = -32603;
r.add(versionName, new JsonPrimitive("2.0"));
if (id != null) {
r.add("id", new JsonPrimitive(id));
}
GsonBuilder gb = JSONParserWrapper.defaultGsonBuilder();
final JsonObject error = JsonServlet.getError(versionName, code, ex, gb);
r.add("error", error);
GsonBuilder builder = JSONParserWrapper.defaultGsonBuilder();
String out = builder.create().toJson( r);
return out;
}
}
| Java |
package org.rapla.rest.server;
import java.util.ArrayList;
import java.util.List;
import javax.jws.WebParam;
import javax.jws.WebService;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.entities.dynamictype.internal.DynamicTypeImpl;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.servletpages.RaplaPageGenerator;
@WebService
public class RaplaDynamicTypesRestPage extends AbstractRestPage implements RaplaPageGenerator
{
public RaplaDynamicTypesRestPage(RaplaContext context) throws RaplaException {
super(context);
}
public List<DynamicTypeImpl> list(@WebParam(name="classificationType") String classificationType ) throws RaplaException
{
DynamicType[] types = getQuery().getDynamicTypes(classificationType);
List<DynamicTypeImpl> result = new ArrayList<DynamicTypeImpl>();
for ( DynamicType r:types)
{
result.add((DynamicTypeImpl) r);
}
return result;
}
}
| Java |
package org.rapla.rest.server;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import javax.jws.WebParam;
import javax.jws.WebService;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.internal.AllocatableImpl;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.entities.dynamictype.DynamicTypeAnnotations;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.servletpages.RaplaPageGenerator;
import org.rapla.storage.RaplaSecurityException;
@WebService
public class RaplaResourcesRestPage extends AbstractRestPage implements RaplaPageGenerator
{
private Collection<String> CLASSIFICATION_TYPES = Arrays.asList(new String[] {DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESOURCE,DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON});
public RaplaResourcesRestPage(RaplaContext context) throws RaplaException
{
super(context);
}
public List<AllocatableImpl> list(@WebParam(name="user") User user,@WebParam(name="resourceTypes") List<String> resourceTypes, @WebParam(name="attributeFilter") Map<String,String> simpleFilter ) throws RaplaException
{
ClassificationFilter[] filters = getClassificationFilter(simpleFilter, CLASSIFICATION_TYPES, resourceTypes);
Collection<Allocatable> resources = operator.getAllocatables(filters);
List<AllocatableImpl> result = new ArrayList<AllocatableImpl>();
for ( Allocatable r:resources)
{
if ( RaplaComponent.canRead(r, user))
{
result.add((AllocatableImpl) r);
}
}
return result;
}
public AllocatableImpl get(@WebParam(name="user") User user, @WebParam(name="id")String id) throws RaplaException
{
AllocatableImpl resource = (AllocatableImpl) operator.resolve(id, Allocatable.class);
if (!RaplaComponent.canRead(resource, user))
{
throw new RaplaSecurityException("User " + user + " can't read " + resource);
}
return resource;
}
public AllocatableImpl update(@WebParam(name="user") User user, AllocatableImpl resource) throws RaplaException
{
if (!RaplaComponent.canModify(resource, user))
{
throw new RaplaSecurityException("User " + user + " can't modify " + resource);
}
resource.setResolver( operator);
getModification().store( resource );
AllocatableImpl result =(AllocatableImpl) getModification().getPersistant( resource);
return result;
}
public AllocatableImpl create(@WebParam(name="user") User user, AllocatableImpl resource) throws RaplaException
{
if (!getQuery().canCreateReservations(user))
{
throw new RaplaSecurityException("User " + user + " can't modify " + resource);
}
if (resource.getId() != null)
{
throw new RaplaException("Id has to be null for new events");
}
String eventId = operator.createIdentifier(Allocatable.TYPE, 1)[0];
resource.setId( eventId);
resource.setResolver( operator);
resource.setCreateDate( operator.getCurrentTimestamp());
resource.setOwner( user );
getModification().store( resource);
AllocatableImpl result =(AllocatableImpl) getModification().getPersistant( resource);
return result;
}
}
| Java |
package org.rapla.rest.server;
import java.io.IOException;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaContextException;
import org.rapla.servletpages.RaplaPageGenerator;
import org.rapla.storage.dbrm.RemoteServer;
public class RaplaAuthRestPage extends RaplaAPIPage implements RaplaPageGenerator
{
public RaplaAuthRestPage(RaplaContext context) throws RaplaContextException {
super(context);
}
@Override
protected String getServiceAndMethodName(HttpServletRequest request)
{
return RemoteServer.class.getName() +"/auth";
}
@Override
public void generatePage(ServletContext servletContext, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
super.generatePage(servletContext, request, response);
}
}
| Java |
// Copyright 2008 Google Inc.
//
// Licensed 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.rapla.rest.gwtjsonrpc.server;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Date;
import javax.crypto.Mac;
import javax.crypto.ShortBufferException;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
/**
* Utility function to compute and verify XSRF tokens.
* <p>
* {@link JsonServlet} uses this class to verify tokens appearing in the custom
* <code>xsrfKey</code> JSON request property. The tokens protect against
* cross-site request forgery by depending upon the browser's security model.
* The classic browser security model prohibits a script from site A from
* reading any data received from site B. By sending unforgeable tokens from the
* server and asking the client to return them to us, the client script must
* have had read access to the token at some point and is therefore also from
* our server.
*/
public class SignedToken {
private static final int INT_SZ = 4;
private static final String MAC_ALG = "HmacSHA1";
/**
* Generate a random key for use with the XSRF library.
*
* @return a new private key, base 64 encoded.
*/
public static String generateRandomKey() {
final byte[] r = new byte[26];
new SecureRandom().nextBytes(r);
return encodeBase64(r);
}
private final int maxAge;
private final SecretKeySpec key;
private final SecureRandom rng;
private final int tokenLength;
/**
* Create a new utility, using a randomly generated key.
*
* @param age the number of seconds a token may remain valid.
* @throws XsrfException the JVM doesn't support the necessary algorithms.
*/
public SignedToken(final int age) throws XsrfException {
this(age, generateRandomKey());
}
/**
* Create a new utility, using the specific key.
*
* @param age the number of seconds a token may remain valid.
* @param keyBase64 base 64 encoded representation of the key.
* @throws XsrfException the JVM doesn't support the necessary algorithms.
*/
public SignedToken(final int age, final String keyBase64)
throws XsrfException {
maxAge = age > 5 ? age / 5 : age;
key = new SecretKeySpec(decodeBase64(keyBase64), MAC_ALG);
rng = new SecureRandom();
tokenLength = 2 * INT_SZ + newMac().getMacLength();
}
/** @return maximum age of a signed token, in seconds. */
public int getMaxAge() {
return maxAge > 0 ? maxAge * 5 : maxAge;
}
// /**
// * Get the text of a signed token which is stored in a cookie.
// *
// * @param cookieName the name of the cookie to get the text from.
// * @return the signed text; null if the cookie is not set or the cookie's
// * token was forged.
// */
// public String getCookieText(final String cookieName) {
// final String val = ServletCookieAccess.get(cookieName);
// boolean ok;
// try {
// ok = checkToken(val, null) != null;
// } catch (XsrfException e) {
// ok = false;
// }
// return ok ? ServletCookieAccess.getTokenText(cookieName) : null;
// }
/**
* Generate a new signed token.
*
* @param text the text string to sign. Typically this should be some
* user-specific string, to prevent replay attacks. The text must be
* safe to appear in whatever context the token itself will appear, as
* the text is included on the end of the token.
* @return the signed token. The text passed in <code>text</code> will appear
* after the first ',' in the returned token string.
* @throws XsrfException the JVM doesn't support the necessary algorithms.
*/
public String newToken(final String text, Date now) throws XsrfException {
final int q = rng.nextInt();
final byte[] buf = new byte[tokenLength];
encodeInt(buf, 0, q);
encodeInt(buf, INT_SZ, now(now) ^ q);
computeToken(buf, text);
return encodeBase64(buf) + '$' + text;
}
/**
* Validate a returned token.
*
* @param tokenString a token string previously created by this class.
* @param text text that must have been used during {@link #newToken(String)}
* in order for the token to be valid. If null the text will be taken
* from the token string itself.
* @return true if the token is valid; false if the token is null, the empty
* string, has expired, does not match the text supplied, or is a
* forged token.
* @throws XsrfException the JVM doesn't support the necessary algorithms to
* generate a token. XSRF services are simply not available.
*/
public ValidToken checkToken(final String tokenString, final String text,Date now)
throws XsrfException {
if (tokenString == null || tokenString.length() == 0) {
return null;
}
final int s = tokenString.indexOf('$');
if (s <= 0) {
return null;
}
final String recvText = tokenString.substring(s + 1);
final byte[] in;
try {
String substring = tokenString.substring(0, s);
in = decodeBase64(substring);
} catch (RuntimeException e) {
return null;
}
if (in.length != tokenLength) {
return null;
}
final int q = decodeInt(in, 0);
final int c = decodeInt(in, INT_SZ) ^ q;
final int n = now( now);
if (maxAge > 0 && Math.abs(c - n) > maxAge) {
return null;
}
final byte[] gen = new byte[tokenLength];
System.arraycopy(in, 0, gen, 0, 2 * INT_SZ);
computeToken(gen, text != null ? text : recvText);
if (!Arrays.equals(gen, in)) {
return null;
}
return new ValidToken(maxAge > 0 && c + (maxAge >> 1) <= n, recvText);
}
private void computeToken(final byte[] buf, final String text)
throws XsrfException {
final Mac m = newMac();
m.update(buf, 0, 2 * INT_SZ);
m.update(toBytes(text));
try {
m.doFinal(buf, 2 * INT_SZ);
} catch (ShortBufferException e) {
throw new XsrfException("Unexpected token overflow", e);
}
}
private Mac newMac() throws XsrfException {
try {
final Mac m = Mac.getInstance(MAC_ALG);
m.init(key);
return m;
} catch (NoSuchAlgorithmException e) {
throw new XsrfException(MAC_ALG + " not supported", e);
} catch (InvalidKeyException e) {
throw new XsrfException("Invalid private key", e);
}
}
private static int now(Date now) {
return (int) (now.getTime() / 5000L);
}
private static byte[] decodeBase64(final String s) {
return Base64.decodeBase64(toBytes(s));
}
private static String encodeBase64(final byte[] buf) {
return toString(Base64.encodeBase64(buf));
}
private static void encodeInt(final byte[] buf, final int o, int v) {
buf[o + 3] = (byte) v;
v >>>= 8;
buf[o + 2] = (byte) v;
v >>>= 8;
buf[o + 1] = (byte) v;
v >>>= 8;
buf[o] = (byte) v;
}
private static int decodeInt(final byte[] buf, final int o) {
int r = buf[o] << 8;
r |= buf[o + 1] & 0xff;
r <<= 8;
r |= buf[o + 2] & 0xff;
return (r << 8) | (buf[o + 3] & 0xff);
}
private static byte[] toBytes(final String s) {
final byte[] r = new byte[s.length()];
for (int k = r.length - 1; k >= 0; k--) {
r[k] = (byte) s.charAt(k);
}
return r;
}
private static String toString(final byte[] b) {
final StringBuilder r = new StringBuilder(b.length);
for (int i = 0; i < b.length; i++) {
r.append((char) b[i]);
}
return r.toString();
}
}
| Java |
// Copyright 2008 Google Inc.
//
// Licensed 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.rapla.rest.gwtjsonrpc.server;
/** Indicates the requested method is not known. */
@SuppressWarnings("serial")
class NoSuchRemoteMethodException extends RuntimeException {
}
| Java |
// Copyright 2008 Google Inc.
//
// Licensed 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.rapla.rest.gwtjsonrpc.server;
/** A validated token from {@link SignedToken#checkToken(String, String)} */
public class ValidToken {
private final boolean refresh;
private final String data;
public ValidToken(final boolean ref, final String d) {
refresh = ref;
data = d;
}
/** The text protected by the token's encryption key. */
public String getData() {
return data;
}
/** True if the token's life span is almost half-over and should be renewed. */
public boolean needsRefresh() {
return refresh;
}
}
| Java |
// Copyright 2008 Google Inc.
//
// Licensed 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.rapla.rest.gwtjsonrpc.server;
/** Indicates the requested method is not known. */
@SuppressWarnings("serial")
public class XsrfException extends Exception {
public XsrfException(final String message) {
super(message);
}
public XsrfException(final String message, final Throwable why) {
super(message, why);
}
}
| Java |
// Copyright 2008 Google Inc.
//
// Licensed 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.rapla.rest.gwtjsonrpc.server;
import java.lang.reflect.Type;
import com.google.gson.InstanceCreator;
import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
final class CallDeserializer implements
JsonDeserializer<ActiveCall>, InstanceCreator<ActiveCall> {
private final ActiveCall req;
private final JsonServlet server;
CallDeserializer(final ActiveCall call, final JsonServlet jsonServlet) {
req = call;
server = jsonServlet;
}
@Override
public ActiveCall createInstance(final Type type) {
return req;
}
@Override
public ActiveCall deserialize(final JsonElement json, final Type typeOfT,
final JsonDeserializationContext context) throws JsonParseException,
NoSuchRemoteMethodException {
if (!json.isJsonObject()) {
throw new JsonParseException("Expected object");
}
final JsonObject in = json.getAsJsonObject();
req.id = in.get("id");
final JsonElement jsonrpc = in.get("jsonrpc");
final JsonElement version = in.get("version");
if (isString(jsonrpc) && version == null) {
final String v = jsonrpc.getAsString();
if ("2.0".equals(v)) {
req.versionName = "jsonrpc";
req.versionValue = jsonrpc;
} else {
throw new JsonParseException("Expected jsonrpc=2.0");
}
} else if (isString(version) && jsonrpc == null) {
final String v = version.getAsString();
if ("1.1".equals(v)) {
req.versionName = "version";
req.versionValue = version;
} else {
throw new JsonParseException("Expected version=1.1");
}
} else {
throw new JsonParseException("Expected version=1.1 or jsonrpc=2.0");
}
final JsonElement method = in.get("method");
if (!isString(method)) {
throw new JsonParseException("Expected method name as string");
}
req.method = server.lookupMethod(method.getAsString());
if (req.method == null) {
throw new NoSuchRemoteMethodException();
}
final Type[] paramTypes = req.method.getParamTypes();
final JsonElement params = in.get("params");
if (params != null) {
if (!params.isJsonArray()) {
throw new JsonParseException("Expected params array");
}
final JsonArray paramsArray = params.getAsJsonArray();
if (paramsArray.size() != paramTypes.length) {
throw new JsonParseException("Expected " + paramTypes.length
+ " parameter values in params array");
}
final Object[] r = new Object[paramTypes.length];
for (int i = 0; i < r.length; i++) {
final JsonElement v = paramsArray.get(i);
if (v != null) {
r[i] = context.deserialize(v, paramTypes[i]);
}
}
req.params = r;
} else {
if (paramTypes.length != 0) {
throw new JsonParseException("Expected params array");
}
req.params = JsonServlet.NO_PARAMS;
}
return req;
}
private static boolean isString(final JsonElement e) {
return e != null && e.isJsonPrimitive()
&& e.getAsJsonPrimitive().isString();
}
}
| Java |
// Copyright 2008 Google Inc.
//
// Licensed 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.rapla.rest.gwtjsonrpc.server;
import static javax.servlet.http.HttpServletResponse.SC_BAD_REQUEST;
import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.nio.ByteBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CodingErrorAction;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.jws.WebService;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.codec.binary.Base64;
import org.rapla.components.util.ParseDateException;
import org.rapla.components.util.SerializableDateTimeFormat;
import org.rapla.entities.DependencyException;
import org.rapla.framework.RaplaException;
import org.rapla.framework.logger.Logger;
import org.rapla.rest.gwtjsonrpc.common.FutureResult;
import org.rapla.rest.gwtjsonrpc.common.JSONParserWrapper;
import org.rapla.rest.gwtjsonrpc.common.JsonConstants;
import org.rapla.rest.jsonpatch.mergepatch.server.JsonMergePatch;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import com.google.gson.JsonSyntaxException;
/**
* Forward JSON based RPC requests onto services.
* <b>JSON-RPC 1.1</b><br>
* Calling conventions match the JSON-RPC 1.1 working draft from 7 August 2006
* (<a href="http://json-rpc.org/wd/JSON-RPC-1-1-WD-20060807.html">draft</a>).
* Only positional parameters are supported.
* <p>
* <b>JSON-RPC 2.0</b><br>
* Calling conventions match the JSON-RPC 2.0 specification.
* <p>
* When supported by the browser/client, the "gzip" encoding is used to compress
* the resulting JSON, reducing transfer time for the response data.
*/
public class JsonServlet {
public final static String JSON_METHOD = "method";
static final Object[] NO_PARAMS = {};
Class class1;
private Map<String, MethodHandle> myMethods;
Logger logger;
public JsonServlet(final Logger logger, final Class class1) throws RaplaException {
this.class1 = class1;
this.logger = logger;
myMethods = methods(class1);
if (myMethods.isEmpty()) {
throw new RaplaException("No public service methods declared in " + class1 + " Did you forget the javax.jws.WebService annotation?");
}
}
public Class getInterfaceClass() {
return class1;
}
/** Create a GsonBuilder to parse a request or return a response. */
protected GsonBuilder createGsonBuilder() {
return JSONParserWrapper.defaultGsonBuilder();
}
/**
* Lookup a method implemented by this servlet.
*
* @param methodName
* name of the method.
* @return the method handle; null if the method is not declared.
*/
protected MethodHandle lookupMethod(final String methodName) {
return myMethods.get(methodName);
}
/** @return maximum size of a JSON request, in bytes */
protected int maxRequestSize() {
// Our default limit of 100 MB should be sufficient for nearly any
// application. It takes a long time to format this on the client
// or to upload it.
//
return 100 * 1024 * 1024;
}
public void service(final HttpServletRequest req, final HttpServletResponse resp, ServletContext servletContext, final Object service) throws IOException {
ActiveCall call = new ActiveCall(req, resp);
call.noCache();
// if (!acceptJSON(call)) {
// textError(call, SC_BAD_REQUEST, "Must Accept " +
// JsonConstants.JSON_TYPE);
// return;
// }
boolean isPatch = req.getMethod().equals("PATCH");
doService(service, call);
if ( isPatch && !call.hasFailed())
{
Object result = call.result;
call = new ActiveCall(req, resp);
try
{
final Gson gs = createGsonBuilder().create();
JsonElement unpatchedObject = gs.toJsonTree(result);
String patchBody = readBody(call);
JsonElement patchElement = new JsonParser().parse( patchBody);
final JsonMergePatch patch = JsonMergePatch.fromJson(patchElement);
final JsonElement patchedObject = patch.apply(unpatchedObject);
Object patchMethod = req.getAttribute("patchMethod");
if ( patchMethod == null )
{
throw new RaplaException("request attribute patchMethod or patchParameter is missing.");
}
req.setAttribute("method", patchMethod);
String patchedObjectToString =gs.toJson( patchedObject);
req.setAttribute("postBody", patchedObjectToString);
doService(service, call);
}
catch (Exception ex)
{
call.externalFailure = ex;
}
}
final String out = formatResult(call);
RPCServletUtils.writeResponse(servletContext, call.httpResponse, out, out.length() > 256 && RPCServletUtils.acceptsGzipEncoding(call.httpRequest));
}
public void serviceError(final HttpServletRequest req, final HttpServletResponse resp, ServletContext servletContext, final Throwable ex) throws IOException {
final ActiveCall call = new ActiveCall(req, resp);
call.versionName = "jsonrpc";
call.versionValue = new JsonPrimitive("2.0");
call.noCache();
call.onInternalFailure(ex);
final String out = formatResult(call);
RPCServletUtils.writeResponse(servletContext, call.httpResponse, out, out.length() > 256 && RPCServletUtils.acceptsGzipEncoding(call.httpRequest));
}
// private boolean acceptJSON(final CallType call) {
// final String accepts = call.httpRequest.getHeader("Accept");
// if (accepts == null) {
// // A really odd client, it didn't send us an accept header?
// //
// return false;
// }
//
// if (JsonConstants.JSON_TYPE.equals(accepts)) {
// // Common case, as our JSON client side code sets only this
// //
// return true;
// }
//
// // The browser may take JSON, but also other types. The popular
// // Opera browser will add other accept types to our AJAX requests
// // even though our AJAX handler wouldn't be able to actually use
// // the data. The common case for these is to start with our own
// // type, then others, so we special case it before we go through
// // the expense of splitting the Accepts header up.
// //
// if (accepts.startsWith(JsonConstants.JSON_TYPE + ",")) {
// return true;
// }
// final String[] parts = accepts.split("[ ,;][ ,;]*");
// for (final String p : parts) {
// if (JsonConstants.JSON_TYPE.equals(p)) {
// return true;
// }
// }
//
// // Assume the client is busted and won't take JSON back.
// //
// return false;
// }
private void doService(final Object service, final ActiveCall call) throws IOException {
try {
try {
String httpMethod = call.httpRequest.getMethod();
if ("GET".equals(httpMethod) || "PATCH".equals(httpMethod)) {
parseGetRequest(call);
} else if ("POST".equals(httpMethod)) {
parsePostRequest(call);
} else {
call.httpResponse.setStatus(SC_BAD_REQUEST);
call.onFailure(new Exception("Unsupported HTTP method"));
return;
}
} catch (JsonParseException err) {
if (err.getCause() instanceof NoSuchRemoteMethodException) {
// GSON seems to catch our own exception and wrap it...
//
throw (NoSuchRemoteMethodException) err.getCause();
}
call.httpResponse.setStatus(SC_BAD_REQUEST);
call.onFailure(new Exception("Error parsing request " + err.getMessage(), err));
return;
}
} catch (NoSuchRemoteMethodException err) {
call.httpResponse.setStatus(SC_NOT_FOUND);
call.onFailure(new Exception("No such service method"));
return;
}
if (!call.isComplete()) {
call.method.invoke(service, call.params, call);
}
}
private void parseGetRequest(final ActiveCall call) {
final HttpServletRequest req = call.httpRequest;
if ("2.0".equals(req.getParameter("jsonrpc"))) {
final JsonObject d = new JsonObject();
d.addProperty("jsonrpc", "2.0");
d.addProperty("method", req.getParameter("method"));
d.addProperty("id", req.getParameter("id"));
try {
String parameter = req.getParameter("params");
final byte[] params = parameter.getBytes("ISO-8859-1");
JsonElement parsed;
try {
parsed = new JsonParser().parse(parameter);
} catch (JsonParseException e) {
final String p = new String(Base64.decodeBase64(params), "UTF-8");
parsed = new JsonParser().parse(p);
}
d.add("params", parsed);
} catch (UnsupportedEncodingException e) {
throw new JsonParseException("Cannot parse params", e);
}
try {
final GsonBuilder gb = createGsonBuilder();
gb.registerTypeAdapter(ActiveCall.class, new CallDeserializer(call, this));
gb.create().fromJson(d, ActiveCall.class);
} catch (JsonParseException err) {
call.method = null;
call.params = null;
throw err;
}
} else { /* JSON-RPC 1.1 or GET REST API */
String body = (String)req.getAttribute("postBody");
mapRequestToCall(call, req, body);
}
}
public void mapRequestToCall(final ActiveCall call, final HttpServletRequest req, String body) {
final Gson gs = createGsonBuilder().create();
String methodName = (String) req.getAttribute(JSON_METHOD);
if (methodName != null) {
call.versionName = "jsonrpc";
call.versionValue = new JsonPrimitive("2.0");
} else {
methodName = req.getParameter("method");
call.versionName = "version";
call.versionValue = new JsonPrimitive("1.1");
}
call.method = lookupMethod(methodName);
if (call.method == null) {
throw new NoSuchRemoteMethodException();
}
final Type[] paramTypes = call.method.getParamTypes();
String[] paramNames = call.method.getParamNames();
final Object[] r = new Object[paramTypes.length];
for (int i = 0; i < r.length; i++) {
Type type = paramTypes[i];
String name = paramNames[i];
if (name == null && !call.versionName.equals("jsonrpc")) {
name = "param" + i;
}
{
// First search in the request attributes
Object attribute = req.getAttribute(name);
Object paramValue;
if ( attribute != null)
{
paramValue =attribute;
Class attributeClass = attribute.getClass();
// we try to convert string and jsonelements to the parameter type (if the parameter type is not string or jsonelement)
if ( attributeClass.equals(String.class) && !type.equals(String.class) )
{
JsonParser parser = new JsonParser();
JsonElement parsed = parser.parse((String)attribute);
paramValue = gs.fromJson(parsed, type);
}
else if (JsonElement.class.isAssignableFrom(attributeClass) && !type.equals(JsonElement.class))
{
JsonElement parsed = (JsonElement) attribute;
paramValue = gs.fromJson(parsed, type);
}
else
{
paramValue =attribute;
}
}
// then in request parameters
else
{
String v = null;
v = req.getParameter(name);
// if not found in request use body
if ( v == null && body != null && !body.isEmpty())
{
v = body;
}
if (v == null) {
paramValue = null;
} else if (type == String.class) {
paramValue = v;
} else if (type == Date.class) {
// special case for handling date parameters with the
// ':' char i it
try {
paramValue = SerializableDateTimeFormat.INSTANCE.parseTimestamp(v);
} catch (ParseDateException e) {
throw new JsonSyntaxException(v, e);
}
} else if (type instanceof Class<?> && ((Class<?>) type).isPrimitive()) {
// Primitive type, use the JSON representation of that
// type.
//
paramValue = gs.fromJson(v, type);
} else {
// Assume it is like a java.sql.Timestamp or something
// and treat
// the value as JSON string.
//
JsonParser parser = new JsonParser();
JsonElement parsed = parser.parse(v);
paramValue = gs.fromJson(parsed, type);
}
}
r[i] = paramValue;
}
}
call.params = r;
}
private static boolean isBodyJson(final ActiveCall call) {
String type = call.httpRequest.getContentType();
if (type == null) {
return false;
}
int semi = type.indexOf(';');
if (semi >= 0) {
type = type.substring(0, semi).trim();
}
return JsonConstants.JSON_TYPE.equals(type);
}
private static boolean isBodyUTF8(final ActiveCall call) {
String enc = call.httpRequest.getCharacterEncoding();
if (enc == null) {
enc = "";
}
return enc.toLowerCase().contains(JsonConstants.JSON_ENC.toLowerCase());
}
private String readBody(final ActiveCall call) throws IOException {
if (!isBodyJson(call)) {
throw new JsonParseException("Invalid Request Content-Type");
}
if (!isBodyUTF8(call)) {
throw new JsonParseException("Invalid Request Character-Encoding");
}
final int len = call.httpRequest.getContentLength();
if (len < 0) {
throw new JsonParseException("Invalid Request Content-Length");
}
if (len == 0) {
throw new JsonParseException("Invalid Request POST Body Required");
}
if (len > maxRequestSize()) {
throw new JsonParseException("Invalid Request POST Body Too Large");
}
final InputStream in = call.httpRequest.getInputStream();
if (in == null) {
throw new JsonParseException("Invalid Request POST Body Required");
}
try {
final byte[] body = new byte[len];
int off = 0;
while (off < len) {
final int n = in.read(body, off, len - off);
if (n <= 0) {
throw new JsonParseException("Invalid Request Incomplete Body");
}
off += n;
}
final CharsetDecoder d = Charset.forName(JsonConstants.JSON_ENC).newDecoder();
d.onMalformedInput(CodingErrorAction.REPORT);
d.onUnmappableCharacter(CodingErrorAction.REPORT);
try {
return d.decode(ByteBuffer.wrap(body)).toString();
} catch (CharacterCodingException e) {
throw new JsonParseException("Invalid Request Not UTF-8", e);
}
} finally {
in.close();
}
}
private void parsePostRequest(final ActiveCall call) throws UnsupportedEncodingException, IOException {
try {
HttpServletRequest request = call.httpRequest;
String attribute = (String)request.getAttribute(JSON_METHOD);
String postBody = readBody(call);
final GsonBuilder gb = createGsonBuilder();
if ( attribute != null)
{
mapRequestToCall(call, request, postBody);
}
else
{
gb.registerTypeAdapter(ActiveCall.class, new CallDeserializer(call, this));
Gson mapper = gb.create();
mapper.fromJson(postBody, ActiveCall.class);
}
} catch (JsonParseException err) {
call.method = null;
call.params = null;
throw err;
}
}
private String formatResult(final ActiveCall call) throws UnsupportedEncodingException, IOException {
final GsonBuilder gb = createGsonBuilder();
gb.registerTypeAdapter(call.getClass(), new JsonSerializer<ActiveCall>() {
@Override
public JsonElement serialize(final ActiveCall src, final Type typeOfSrc, final JsonSerializationContext context) {
if (call.externalFailure != null) {
final String msg;
if (call.method != null) {
msg = "Error in " + call.method.getName();
} else {
msg = "Error";
}
logger.error(msg, call.externalFailure);
}
Throwable failure = src.externalFailure != null ? src.externalFailure : src.internalFailure;
Object result = src.result;
if (result instanceof FutureResult) {
try {
result = ((FutureResult) result).get();
} catch (Exception e) {
failure = e;
}
}
final JsonObject r = new JsonObject();
if (src.versionName == null || src.versionValue == null)
{
r.add("jsonrpc", new JsonPrimitive("2.0"));
}
else
{
r.add(src.versionName, src.versionValue);
}
if (src.id != null) {
r.add("id", src.id);
}
if (failure != null) {
final int code = to2_0ErrorCode(src);
final JsonObject error = getError(src.versionName, code, failure, gb);
r.add("error", error);
} else {
r.add("result", context.serialize(result));
}
return r;
}
});
Gson create = gb.create();
final StringWriter o = new StringWriter();
create.toJson(call, o);
o.close();
String string = o.toString();
return string;
}
private int to2_0ErrorCode(final ActiveCall src) {
final Throwable e = src.externalFailure;
final Throwable i = src.internalFailure;
if (e instanceof NoSuchRemoteMethodException || i instanceof NoSuchRemoteMethodException) {
return -32601 /* Method not found. */;
}
if (e instanceof IllegalArgumentException || i instanceof IllegalArgumentException) {
return -32602 /* Invalid paramters. */;
}
if (e instanceof JsonParseException || i instanceof JsonParseException) {
return -32700 /* Parse error. */;
}
return -32603 /* Internal error. */;
}
// private static void textError(final ActiveCall call, final int status,
// final String message) throws IOException {
// final HttpServletResponse r = call.httpResponse;
// r.setStatus(status);
// r.setContentType("text/plain; charset=" + ENC);
//
// final Writer w = new OutputStreamWriter(r.getOutputStream(), ENC);
// try {
// w.write(message);
// } finally {
// w.close();
// }
// }
public static JsonObject getError(String version, int code, Throwable failure, GsonBuilder gb) {
final JsonObject error = new JsonObject();
String message = failure.getMessage();
if (message == null) {
message = failure.toString();
}
Gson gson = gb.create();
if ("jsonrpc".equals(version)) {
error.addProperty("code", code);
error.addProperty("message", message);
JsonObject errorData = new JsonObject();
errorData.addProperty("exception", failure.getClass().getName());
// FIXME Replace with generic solution for exception param
// serialization
if (failure instanceof DependencyException) {
JsonArray params = new JsonArray();
for (String dep : ((DependencyException) failure).getDependencies()) {
params.add(new JsonPrimitive(dep));
}
errorData.add("params", params);
}
JsonArray stackTrace = new JsonArray();
for (StackTraceElement el : failure.getStackTrace()) {
JsonElement jsonRep = gson.toJsonTree(el);
stackTrace.add( jsonRep);
}
errorData.add("stacktrace", stackTrace);
error.add("data", errorData);
} else {
error.addProperty("name", "JSONRPCError");
error.addProperty("code", 999);
error.addProperty("message", message);
}
return error;
}
private static Map<String, MethodHandle> methods(Class class1) {
final Class d = findInterface(class1);
if (d == null) {
return Collections.<String, MethodHandle> emptyMap();
}
final Map<String, MethodHandle> r = new HashMap<String, MethodHandle>();
for (final Method m : d.getMethods()) {
if (!Modifier.isPublic(m.getModifiers())) {
continue;
}
final MethodHandle h = new MethodHandle(m);
r.put(h.getName(), h);
}
return Collections.unmodifiableMap(r);
}
private static Class findInterface(Class<?> c) {
while (c != null) {
if ( c.getAnnotation(WebService.class) != null) {
return c;
}
for (final Class<?> i : c.getInterfaces()) {
final Class r = findInterface(i);
if (r != null) {
return r;
}
}
c = c.getSuperclass();
}
return null;
}
}
| Java |
// Copyright 2008 Google Inc.
//
// Licensed 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.rapla.rest.gwtjsonrpc.server;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import javax.jws.WebParam;
/**
* Pairing of a specific implementation and method.
*/
public class MethodHandle {
//private final RemoteJsonService imp;
private final Method method;
private final Type[] parameterTypes;
private String[] parameterNames;
/**
* Create a new handle for a specific service implementation and method.
*
* @param imp instance of the service all calls will be made on.
* @param method Java method to invoke on <code>imp</code>. The last parameter
* of the method must accept an {@link org.rapla.rest.gwtjsonrpc.common.AsyncCallback}
* and the method must return void.
*/
MethodHandle( final Method method) {
//this.imp = imp;
this.method = method;
final Type[] args = method.getGenericParameterTypes();
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
parameterNames = new String[args.length ];
for (int i=0;i<args.length;i++)
{
Annotation[] annot= parameterAnnotations[i];
String paramterName = null;
for ( Annotation a:annot)
{
Class<? extends Annotation> annotationType = a.annotationType();
if ( annotationType.equals( WebParam.class))
{
paramterName = ((WebParam)a).name();
}
}
if ( paramterName != null)
{
parameterNames[i] = paramterName;
}
}
parameterTypes = new Type[args.length ];
System.arraycopy(args, 0, parameterTypes, 0, parameterTypes.length);
}
/**
* @return unique name of the method within the service.
*/
public String getName() {
return method.getName();
}
/** @return an annotation attached to the method's description. */
public <T extends Annotation> T getAnnotation(final Class<T> t) {
return method.getAnnotation(t);
}
/**
* @return true if this method requires positional arguments.
*/
public Type[] getParamTypes() {
return parameterTypes;
}
public String[] getParamNames()
{
return parameterNames;
}
/**
* Invoke this method with the specified arguments, updating the callback.
*
* @param arguments arguments to the method. May be the empty array if no
* parameters are declared beyond the AsyncCallback, but must not be
* null.
* @param imp the implementing object
* @param callback the callback the implementation will invoke onSuccess or
* onFailure on as it performs its work. Only the last onSuccess or
* onFailure invocation matters.
*/
public void invoke(final Object imp,final Object[] arguments,final ActiveCall callback) {
try {
Object result = method.invoke(imp, arguments);
callback.onSuccess(result);
} catch (InvocationTargetException e) {
final Throwable c = e.getCause();
if (c != null) {
callback.onInternalFailure(c);
} else {
callback.onInternalFailure(e);
}
} catch (IllegalAccessException e) {
callback.onInternalFailure(e);
} catch (RuntimeException e) {
callback.onInternalFailure(e);
} catch (Error e) {
callback.onInternalFailure(e);
}
}
}
| Java |
// Copyright 2008 Google Inc.
//
// Licensed 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.rapla.rest.gwtjsonrpc.server;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.rapla.rest.gwtjsonrpc.common.AsyncCallback;
import com.google.gson.JsonElement;
/** An active RPC call. */
public class ActiveCall implements AsyncCallback<Object> {
protected final HttpServletRequest httpRequest;
protected final HttpServletResponse httpResponse;
JsonElement id;
String versionName;
JsonElement versionValue;
MethodHandle method;
Object[] params;
Object result;
Throwable externalFailure;
Throwable internalFailure;
/**
* Create a new call.
*
* @param req the request.
* @param resp the response.
*/
public ActiveCall(final HttpServletRequest req, final HttpServletResponse resp) {
httpRequest = req;
httpResponse = resp;
}
/**
* @return true if this call has something to send to the client; false if the
* call still needs to be computed further in order to come up with a
* success return value or a failure
*/
public final boolean isComplete() {
return result != null || externalFailure != null || internalFailure != null;
}
@Override
public final void onSuccess(final Object result) {
this.result = result;
this.externalFailure = null;
this.internalFailure = null;
}
@Override
public void onFailure(final Throwable error) {
this.result = null;
this.externalFailure = error;
this.internalFailure = null;
}
public final void onInternalFailure(final Throwable error) {
this.result = null;
this.externalFailure = null;
this.internalFailure = error;
}
/** Mark the response to be uncached by proxies and browsers. */
public void noCache() {
httpResponse.setHeader("Expires", "Fri, 01 Jan 1980 00:00:00 GMT");
httpResponse.setHeader("Pragma", "no-cache");
httpResponse.setHeader("Cache-Control", "no-cache, must-revalidate");
}
public boolean hasFailed() {
return externalFailure != null || internalFailure != null;
}
}
| Java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.