You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@wicket.apache.org by "Jesse Long (JIRA)" <ji...@apache.org> on 2012/10/04 14:01:07 UTC
[jira] [Created] (WICKET-4802) Standard IDataColumn
Jesse Long created WICKET-4802:
----------------------------------
Summary: Standard IDataColumn
Key: WICKET-4802
URL: https://issues.apache.org/jira/browse/WICKET-4802
Project: Wicket
Issue Type: New Feature
Components: wicket-extensions
Affects Versions: 6.1.0
Reporter: Jesse Long
Priority: Minor
In Igor's book he describes a way of exporting a data table to CSV. It requires tagging exportable columns with a interface, which allows retrieving of the data for the column by passing it the row model.
I, and I'm sure many others, have implemented this functionality, and we all have our own CSVExportToolbar, or something similar. The problem is that each export implementation is checking for instances of their own hand-crafted IDataColumn interface. This makes it difficult for people to write libraries that provide columns that will be exportable across the board.
I propose that we add a standard IDataColumn that can be used to tagging exportable columns, and which every CSVExportToolbar and ExcelExportToolbar etc can check for when determining which columns to use to export.
Something like:
/** does not need sort parameter, does not need to extend IColumn */
public interface IDataColumn<R, T>
{
/** get data for row by passing row model, in imodel format to allow this method to be used for rendering in an abstract implementation. */
IModel<T> getDataModel(IModel<R> rowModel);
/** get column header, useful in exporting. same signature as AbstractColumn method */
IModel<String> getDisplayModel();
}
Then an abstract implementation, where the user only needs to implement getDataModel()
public abstract class AbstractDataColumn<R, S, T>
extends AbstractColumn<R, S>
implements IDataColumn<R, T>
{
// normal AbstractColumn constructors.
protected Component createNewDisplayComponent(String componentId, IModel<T> dataModel)
{
return new Label(componentId, dataModel);
}
@Override
public void populateItem(Item<ICellPopulator<R>> cellItem, String componentId, IModel<R> rowModel)
{
cellItem.add(createNewDisplayComponent(componentId, getDataModel(rowModel)));
}
}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Commented] (WICKET-4802) Add functionality to be able to
export DataTable content
Posted by "Jesse Long (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WICKET-4802?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13476883#comment-13476883 ]
Jesse Long commented on WICKET-4802:
------------------------------------
Thank you Martin.
> Add functionality to be able to export DataTable content
> --------------------------------------------------------
>
> Key: WICKET-4802
> URL: https://issues.apache.org/jira/browse/WICKET-4802
> Project: Wicket
> Issue Type: New Feature
> Components: wicket-extensions
> Affects Versions: 6.1.0
> Reporter: Jesse Long
> Assignee: Martin Grigorov
> Priority: Minor
> Fix For: 6.2.0
>
> Attachments: WICKET-4802.patch
>
>
> In Igor's book he describes a way of exporting a data table to CSV. It requires tagging exportable columns with a interface, which allows retrieving of the data for the column by passing it the row model.
> I, and I'm sure many others, have implemented this functionality, and we all have our own CSVExportToolbar, or something similar. The problem is that each export implementation is checking for instances of their own hand-crafted IDataColumn interface. This makes it difficult for people to write libraries that provide columns that will be exportable across the board.
> I propose that we add a standard IDataColumn that can be used to tagging exportable columns, and which every CSVExportToolbar and ExcelExportToolbar etc can check for when determining which columns to use to export.
> Something like:
> /** does not need sort parameter, does not need to extend IColumn */
> public interface IDataColumn<R, T>
> {
> /** get data for row by passing row model, in imodel format to allow this method to be used for rendering in an abstract implementation. */
> IModel<T> getDataModel(IModel<R> rowModel);
> /** get column header, useful in exporting. same signature as AbstractColumn method */
> IModel<String> getDisplayModel();
> }
> Then an abstract implementation, where the user only needs to implement getDataModel()
> public abstract class AbstractDataColumn<R, S, T>
> extends AbstractColumn<R, S>
> implements IDataColumn<R, T>
> {
> // normal AbstractColumn constructors.
> protected Component createNewDisplayComponent(String componentId, IModel<T> dataModel)
> {
> return new Label(componentId, dataModel);
> }
> @Override
> public void populateItem(Item<ICellPopulator<R>> cellItem, String componentId, IModel<R> rowModel)
> {
> cellItem.add(createNewDisplayComponent(componentId, getDataModel(rowModel)));
> }
> }
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Commented] (WICKET-4802) Standard IDataColumn
Posted by "Jesse Long (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WICKET-4802?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13473108#comment-13473108 ]
Jesse Long commented on WICKET-4802:
------------------------------------
There are actually 2 use cases for a standard exportable column type:
1. Allows libraries to provide columns that can be exported by all Wicket apps.
2. Allows libraries to provide exporting code that can export columns in all Wicket apps (Think export to Microsoft Excel library).
I have started implementing this idea here: https://github.com/jesselong/wicket/tree/datatable-export
Its untested, not nicely formatted, undocumented etc, I'll update more when I have time.
> Standard IDataColumn
> --------------------
>
> Key: WICKET-4802
> URL: https://issues.apache.org/jira/browse/WICKET-4802
> Project: Wicket
> Issue Type: New Feature
> Components: wicket-extensions
> Affects Versions: 6.1.0
> Reporter: Jesse Long
> Priority: Minor
>
> In Igor's book he describes a way of exporting a data table to CSV. It requires tagging exportable columns with a interface, which allows retrieving of the data for the column by passing it the row model.
> I, and I'm sure many others, have implemented this functionality, and we all have our own CSVExportToolbar, or something similar. The problem is that each export implementation is checking for instances of their own hand-crafted IDataColumn interface. This makes it difficult for people to write libraries that provide columns that will be exportable across the board.
> I propose that we add a standard IDataColumn that can be used to tagging exportable columns, and which every CSVExportToolbar and ExcelExportToolbar etc can check for when determining which columns to use to export.
> Something like:
> /** does not need sort parameter, does not need to extend IColumn */
> public interface IDataColumn<R, T>
> {
> /** get data for row by passing row model, in imodel format to allow this method to be used for rendering in an abstract implementation. */
> IModel<T> getDataModel(IModel<R> rowModel);
> /** get column header, useful in exporting. same signature as AbstractColumn method */
> IModel<String> getDisplayModel();
> }
> Then an abstract implementation, where the user only needs to implement getDataModel()
> public abstract class AbstractDataColumn<R, S, T>
> extends AbstractColumn<R, S>
> implements IDataColumn<R, T>
> {
> // normal AbstractColumn constructors.
> protected Component createNewDisplayComponent(String componentId, IModel<T> dataModel)
> {
> return new Label(componentId, dataModel);
> }
> @Override
> public void populateItem(Item<ICellPopulator<R>> cellItem, String componentId, IModel<R> rowModel)
> {
> cellItem.add(createNewDisplayComponent(componentId, getDataModel(rowModel)));
> }
> }
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (WICKET-4802) Add functionality to be able to
export DataTable content
Posted by "Martin Grigorov (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WICKET-4802?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Martin Grigorov updated WICKET-4802:
------------------------------------
Summary: Add functionality to be able to export DataTable content (was: Standard IDataColumn)
> Add functionality to be able to export DataTable content
> --------------------------------------------------------
>
> Key: WICKET-4802
> URL: https://issues.apache.org/jira/browse/WICKET-4802
> Project: Wicket
> Issue Type: New Feature
> Components: wicket-extensions
> Affects Versions: 6.1.0
> Reporter: Jesse Long
> Priority: Minor
> Attachments: WICKET-4802.patch
>
>
> In Igor's book he describes a way of exporting a data table to CSV. It requires tagging exportable columns with a interface, which allows retrieving of the data for the column by passing it the row model.
> I, and I'm sure many others, have implemented this functionality, and we all have our own CSVExportToolbar, or something similar. The problem is that each export implementation is checking for instances of their own hand-crafted IDataColumn interface. This makes it difficult for people to write libraries that provide columns that will be exportable across the board.
> I propose that we add a standard IDataColumn that can be used to tagging exportable columns, and which every CSVExportToolbar and ExcelExportToolbar etc can check for when determining which columns to use to export.
> Something like:
> /** does not need sort parameter, does not need to extend IColumn */
> public interface IDataColumn<R, T>
> {
> /** get data for row by passing row model, in imodel format to allow this method to be used for rendering in an abstract implementation. */
> IModel<T> getDataModel(IModel<R> rowModel);
> /** get column header, useful in exporting. same signature as AbstractColumn method */
> IModel<String> getDisplayModel();
> }
> Then an abstract implementation, where the user only needs to implement getDataModel()
> public abstract class AbstractDataColumn<R, S, T>
> extends AbstractColumn<R, S>
> implements IDataColumn<R, T>
> {
> // normal AbstractColumn constructors.
> protected Component createNewDisplayComponent(String componentId, IModel<T> dataModel)
> {
> return new Label(componentId, dataModel);
> }
> @Override
> public void populateItem(Item<ICellPopulator<R>> cellItem, String componentId, IModel<R> rowModel)
> {
> cellItem.add(createNewDisplayComponent(componentId, getDataModel(rowModel)));
> }
> }
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Commented] (WICKET-4802) Standard IDataColumn
Posted by "Martin Grigorov (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WICKET-4802?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13473114#comment-13473114 ]
Martin Grigorov commented on WICKET-4802:
-----------------------------------------
Hi Jesse,
I didn't have time to look at your proposal yet.
I just want to let you know about another implementation of your idea: https://github.com/wicketstuff/core/tree/master/jdk-1.6-parent/wicket-poi-parent, https://github.com/wicketstuff/core/wiki/POI.
> Standard IDataColumn
> --------------------
>
> Key: WICKET-4802
> URL: https://issues.apache.org/jira/browse/WICKET-4802
> Project: Wicket
> Issue Type: New Feature
> Components: wicket-extensions
> Affects Versions: 6.1.0
> Reporter: Jesse Long
> Priority: Minor
>
> In Igor's book he describes a way of exporting a data table to CSV. It requires tagging exportable columns with a interface, which allows retrieving of the data for the column by passing it the row model.
> I, and I'm sure many others, have implemented this functionality, and we all have our own CSVExportToolbar, or something similar. The problem is that each export implementation is checking for instances of their own hand-crafted IDataColumn interface. This makes it difficult for people to write libraries that provide columns that will be exportable across the board.
> I propose that we add a standard IDataColumn that can be used to tagging exportable columns, and which every CSVExportToolbar and ExcelExportToolbar etc can check for when determining which columns to use to export.
> Something like:
> /** does not need sort parameter, does not need to extend IColumn */
> public interface IDataColumn<R, T>
> {
> /** get data for row by passing row model, in imodel format to allow this method to be used for rendering in an abstract implementation. */
> IModel<T> getDataModel(IModel<R> rowModel);
> /** get column header, useful in exporting. same signature as AbstractColumn method */
> IModel<String> getDisplayModel();
> }
> Then an abstract implementation, where the user only needs to implement getDataModel()
> public abstract class AbstractDataColumn<R, S, T>
> extends AbstractColumn<R, S>
> implements IDataColumn<R, T>
> {
> // normal AbstractColumn constructors.
> protected Component createNewDisplayComponent(String componentId, IModel<T> dataModel)
> {
> return new Label(componentId, dataModel);
> }
> @Override
> public void populateItem(Item<ICellPopulator<R>> cellItem, String componentId, IModel<R> rowModel)
> {
> cellItem.add(createNewDisplayComponent(componentId, getDataModel(rowModel)));
> }
> }
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (WICKET-4802) Standard IDataColumn
Posted by "Jesse Long (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WICKET-4802?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Jesse Long updated WICKET-4802:
-------------------------------
Attachment: WICKET-4802.patch
WICKET-4802.patch
Attached is my proposed patch.
Note that I have added the ...data.table.export package.
I have also made PropertyColumn implement IExportableColumn - it is a prime candidate for this. It does not extends AbstractExportableColumn because I'm trying to avoid binary incompatibility.
I have added the export functionality to the data table example in wicket-examples.
The reason I created this ticket was that IExportableColumn as I have implemented it is missing. The rest of the changes I have made are just by suggestion and some default implementations. I will be content if only IExportableColumn makes it in. (It does make sense to at least keep the PropertyColumn changes too).
It should be quite simple to implement Excel etc IDataExporters.
> Standard IDataColumn
> --------------------
>
> Key: WICKET-4802
> URL: https://issues.apache.org/jira/browse/WICKET-4802
> Project: Wicket
> Issue Type: New Feature
> Components: wicket-extensions
> Affects Versions: 6.1.0
> Reporter: Jesse Long
> Priority: Minor
> Attachments: WICKET-4802.patch
>
>
> In Igor's book he describes a way of exporting a data table to CSV. It requires tagging exportable columns with a interface, which allows retrieving of the data for the column by passing it the row model.
> I, and I'm sure many others, have implemented this functionality, and we all have our own CSVExportToolbar, or something similar. The problem is that each export implementation is checking for instances of their own hand-crafted IDataColumn interface. This makes it difficult for people to write libraries that provide columns that will be exportable across the board.
> I propose that we add a standard IDataColumn that can be used to tagging exportable columns, and which every CSVExportToolbar and ExcelExportToolbar etc can check for when determining which columns to use to export.
> Something like:
> /** does not need sort parameter, does not need to extend IColumn */
> public interface IDataColumn<R, T>
> {
> /** get data for row by passing row model, in imodel format to allow this method to be used for rendering in an abstract implementation. */
> IModel<T> getDataModel(IModel<R> rowModel);
> /** get column header, useful in exporting. same signature as AbstractColumn method */
> IModel<String> getDisplayModel();
> }
> Then an abstract implementation, where the user only needs to implement getDataModel()
> public abstract class AbstractDataColumn<R, S, T>
> extends AbstractColumn<R, S>
> implements IDataColumn<R, T>
> {
> // normal AbstractColumn constructors.
> protected Component createNewDisplayComponent(String componentId, IModel<T> dataModel)
> {
> return new Label(componentId, dataModel);
> }
> @Override
> public void populateItem(Item<ICellPopulator<R>> cellItem, String componentId, IModel<R> rowModel)
> {
> cellItem.add(createNewDisplayComponent(componentId, getDataModel(rowModel)));
> }
> }
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Commented] (WICKET-4802) Standard IDataColumn
Posted by "Jesse Long (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WICKET-4802?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13473119#comment-13473119 ]
Jesse Long commented on WICKET-4802:
------------------------------------
Hi Martin,
Thanks for the heads up. That project parses the HTML generated by the data table. Its a really ugly approach (no fault of the author). This is the type of thing I hope my proposal will make simple.
That POI project can implement IDataExporter and get the cell values directly from the column, without HTML markup.
Additional styling for the output can be provided by the column implementing an interface specific to the output target (Excel) that provides styling configuration that makes sense for that IDataExporter.
> Standard IDataColumn
> --------------------
>
> Key: WICKET-4802
> URL: https://issues.apache.org/jira/browse/WICKET-4802
> Project: Wicket
> Issue Type: New Feature
> Components: wicket-extensions
> Affects Versions: 6.1.0
> Reporter: Jesse Long
> Priority: Minor
>
> In Igor's book he describes a way of exporting a data table to CSV. It requires tagging exportable columns with a interface, which allows retrieving of the data for the column by passing it the row model.
> I, and I'm sure many others, have implemented this functionality, and we all have our own CSVExportToolbar, or something similar. The problem is that each export implementation is checking for instances of their own hand-crafted IDataColumn interface. This makes it difficult for people to write libraries that provide columns that will be exportable across the board.
> I propose that we add a standard IDataColumn that can be used to tagging exportable columns, and which every CSVExportToolbar and ExcelExportToolbar etc can check for when determining which columns to use to export.
> Something like:
> /** does not need sort parameter, does not need to extend IColumn */
> public interface IDataColumn<R, T>
> {
> /** get data for row by passing row model, in imodel format to allow this method to be used for rendering in an abstract implementation. */
> IModel<T> getDataModel(IModel<R> rowModel);
> /** get column header, useful in exporting. same signature as AbstractColumn method */
> IModel<String> getDisplayModel();
> }
> Then an abstract implementation, where the user only needs to implement getDataModel()
> public abstract class AbstractDataColumn<R, S, T>
> extends AbstractColumn<R, S>
> implements IDataColumn<R, T>
> {
> // normal AbstractColumn constructors.
> protected Component createNewDisplayComponent(String componentId, IModel<T> dataModel)
> {
> return new Label(componentId, dataModel);
> }
> @Override
> public void populateItem(Item<ICellPopulator<R>> cellItem, String componentId, IModel<R> rowModel)
> {
> cellItem.add(createNewDisplayComponent(componentId, getDataModel(rowModel)));
> }
> }
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Resolved] (WICKET-4802) Add functionality to be able to
export DataTable content
Posted by "Martin Grigorov (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WICKET-4802?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Martin Grigorov resolved WICKET-4802.
-------------------------------------
Resolution: Fixed
Fix Version/s: 6.2.0
Assignee: Martin Grigorov
All of it looks good to me!
Will be available with 6.2.0.
Thanks!
> Add functionality to be able to export DataTable content
> --------------------------------------------------------
>
> Key: WICKET-4802
> URL: https://issues.apache.org/jira/browse/WICKET-4802
> Project: Wicket
> Issue Type: New Feature
> Components: wicket-extensions
> Affects Versions: 6.1.0
> Reporter: Jesse Long
> Assignee: Martin Grigorov
> Priority: Minor
> Fix For: 6.2.0
>
> Attachments: WICKET-4802.patch
>
>
> In Igor's book he describes a way of exporting a data table to CSV. It requires tagging exportable columns with a interface, which allows retrieving of the data for the column by passing it the row model.
> I, and I'm sure many others, have implemented this functionality, and we all have our own CSVExportToolbar, or something similar. The problem is that each export implementation is checking for instances of their own hand-crafted IDataColumn interface. This makes it difficult for people to write libraries that provide columns that will be exportable across the board.
> I propose that we add a standard IDataColumn that can be used to tagging exportable columns, and which every CSVExportToolbar and ExcelExportToolbar etc can check for when determining which columns to use to export.
> Something like:
> /** does not need sort parameter, does not need to extend IColumn */
> public interface IDataColumn<R, T>
> {
> /** get data for row by passing row model, in imodel format to allow this method to be used for rendering in an abstract implementation. */
> IModel<T> getDataModel(IModel<R> rowModel);
> /** get column header, useful in exporting. same signature as AbstractColumn method */
> IModel<String> getDisplayModel();
> }
> Then an abstract implementation, where the user only needs to implement getDataModel()
> public abstract class AbstractDataColumn<R, S, T>
> extends AbstractColumn<R, S>
> implements IDataColumn<R, T>
> {
> // normal AbstractColumn constructors.
> protected Component createNewDisplayComponent(String componentId, IModel<T> dataModel)
> {
> return new Label(componentId, dataModel);
> }
> @Override
> public void populateItem(Item<ICellPopulator<R>> cellItem, String componentId, IModel<R> rowModel)
> {
> cellItem.add(createNewDisplayComponent(componentId, getDataModel(rowModel)));
> }
> }
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira