Lumos Core Guide

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
    <pluginGroups>
    </pluginGroups>

    <proxies>
    </proxies>

    <servers>
        <server>
            <id>amaxgs-libs-release</id>
            <username>amaxgs</username>
            <password>AP3nYPUJA2wZ6gHfhoq2Ar6wwXd</password>
        </server>
        <server>
            <id>amaxgs-libs-snapshot</id>
            <username>amaxgs</username>
            <password>AP3nYPUJA2wZ6gHfhoq2Ar6wwXd</password>
        </server>
        <server>
            <id>ags-central</id>
            <username>amaxgs</username>
            <password>AP3nYPUJA2wZ6gHfhoq2Ar6wwXd</password>
        </server>
    </servers>

    <mirrors>
        <mirror>
            <id>ags-central</id>
            <name>ags-central</name>
            <mirrorOf>central</mirrorOf>
            <url>http://119.119.118.149:8081/artifactory/remote-central</url>
        </mirror>
        <mirror>
            <id>ags-vaadin-addons</id>
            <name>ags-vaadin-addons</name>
            <mirrorOf>vaadin-addons</mirrorOf>
            <url>http://119.119.118.149:8081/artifactory/remote-vaadin-addons</url>
        </mirror>
    </mirrors>

    <profiles>
        <profile>
            <id>amaxgs-libs</id>
            <repositories>
                <repository>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                    <id>amaxgs-libs-release</id>
                    <name>libs-release</name>
                    <url>http://119.119.118.149:8081/artifactory/libs-release</url>
                </repository>
                <repository>
                    <id>amaxgs-libs-snapshot</id>
                    <name>libs-snapshot</name>
                    <url>http://119.119.118.149:8081/artifactory/libs-snapshot</url>
                </repository>
            </repositories>
        </profile>

    </profiles>

    <activeProfiles>
        <activeProfile>amaxgs-libs</activeProfile>
    </activeProfiles>

</settings>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 父项目为lumosframework的父项目，其中包含lumosframework项目模块的依赖管理 -->
    <parent>
        <groupId>com.ags.lumosframework</groupId>
        <artifactId>lumos-parent</artifactId>
        <version>3.1.0-SNAPSHOT</version>
    </parent>

    <artifactId>lumos-demo-parent</artifactId>
    <version>3.1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>demo-sdk</module>
        <module>demo-impl</module>
        <module>demo-web</module>
        <module>demo-app</module>
        <module>demo-rpc-app</module>
        <module>demo-rpc-withregistry-app</module>
    </modules>

    <distributionManagement>
        <!-- 如果是在外地（非内网环境）编码，注意更改地址。 -->
        <snapshotRepository>
            <id>amaxgs-libs-snapshot</id>
            <url>http://119.119.118.149:8081/artifactory/ags-protected-snapshots-local</url>
        </snapshotRepository>
    </distributionManagement>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.ags.lumosframework</groupId>
                <artifactId>lumos-demo-sdk</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>com.ags.lumosframework</groupId>
                <artifactId>lumos-demo-impl</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>com.ags.lumosframework</groupId>
                <artifactId>lumos-demo-web</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>com.ags.lumosframework</groupId>
                <artifactId>lumos-demo-app</artifactId>
                <version>${project.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.ags.lumosframework</groupId>
        <artifactId>lumos-demo-parent</artifactId>
        <version>3.1.0-SNAPSHOT</version>
    </parent>

    <artifactId>lumos-demo-sdk</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.ags.lumosframework</groupId>
            <artifactId>lumos-sdk</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.ags.lumosframework</groupId>
        <artifactId>lumos-demo-parent</artifactId>
        <version>3.1.0-SNAPSHOT</version>
    </parent>
    <artifactId>lumos-demo-impl</artifactId>

    <dependencies>
        <!-- 包含lumos平台自带对象的DAO及Handler实现，此处引用其DAO及Handler实现类的基类 -->
        <dependency>
            <groupId>com.ags.lumosframework</groupId>
            <artifactId>lumos-impl</artifactId>
        </dependency>
        <dependency>
            <groupId>com.ags.lumosframework</groupId>
            <artifactId>lumos-demo-sdk</artifactId>
        </dependency>
    </dependencies>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.ags.lumosframework</groupId>
        <artifactId>lumos-demo-parent</artifactId>
        <version>3.1.0-SNAPSHOT</version>
    </parent>

    <artifactId>lumos-demo-web</artifactId>

    <dependencies>
        <!-- 包含页面的基础组件 -->
        <dependency>
            <groupId>com.ags.lumosframework</groupId>
            <artifactId>lumos-web-vaadin</artifactId>
        </dependency>
        <dependency>
            <groupId>com.ags.lumosframework</groupId>
            <artifactId>lumos-demo-sdk</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!-- 使用Vaadin作为前端框架需要加入此插件用来编译Widgetset -->
            <plugin>
                <groupId>com.vaadin</groupId>
                <artifactId>vaadin-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>update-widgetset</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

package com.ags.lumosframework.demo.sdk.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;

import com.ags.lumosframework.sdk.base.entity.BaseEntity;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
@Entity
@Table(name = "DEMO_BOOK")
public class BookEntity extends BaseEntity {

    @Column(name = "BOOK_NAME", length = 255)
    private String name;

    @Column(name = "INTRODUCTION", length = 1024)
    private String introduction;

    @Column(name = "PRICE")
    private double price;

}

package com.ags.lumosframework.demo.sdk.domain;

import com.ags.lumosframework.demo.sdk.entity.BookEntity;
import com.ags.lumosframework.sdk.base.domain.ObjectBaseImpl;

public class Book extends ObjectBaseImpl<BookEntity> {

    public Book() {
        super(null);
    }

    public Book(BookEntity entity) {
        super(entity);
    }

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

    public void setName(String name) {
        getInternalObject().setName(name);
    }

    public String getIntroduction() {
        return getInternalObject().getIntroduction();
    }

    public void setIntroduction(String introduction) {
        getInternalObject().setIntroduction(introduction);
    }

    public double getPrice() {
        return getInternalObject().getPrice();
    }

    public void setPrice(double price) {
        getInternalObject().setPrice(price);
    }

}

<?xml version="1.1" encoding="UTF-8" standalone="no"?>
<databaseChangeLog
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
        xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.6.xsd">

    <changeSet author="system" id="CREATE_TABLE_DEMO_BOOK">
        <validCheckSum>any</validCheckSum>
        <createTable tableName="DEMO_BOOK">
            <!-- <<<<<<<<<<<<<<<<<<<<<公有属性开始<<<<<<<<<<<<<<<<<<<<<-->
            <column name="ID" type="bigint">
                <constraints primaryKey="true"/>
            </column>
            <column name="PLATFORM_ID" type="varchar(255)"/>
            <column name="COMPANY_ID" type="bigint"/>
            <column name="DESCRIPTION" type="varchar(2000)"/>

            <column name="CREATE_TIME" type="datetime2"/>
            <column name="CREATE_USER_ID" type="bigint"/>
            <column name="CREATE_USER_NAME" type="varchar(255)"/>
            <column name="CREATE_USER_FULL_NAME" type="varchar(255)"/>
            <column name="CREATE_IP" type="varchar(128)"/>
            <column name="DTS_CREATION_BID" type="bigint"/>

            <column name="LM_TIME" type="datetime2"/>
            <column name="LM_USER_ID" type="bigint"/>
            <column name="LM_IP" type="varchar(128)"/>
            <column name="LM_USER_NAME" type="varchar(255)"/>
            <column name="LM_USER_FULL_NAME" type="varchar(255)"/>
            <column name="DTS_MODIFIED_BID" type="bigint"/>

            <column name="DELETE_TIME" type="datetime2"/>
            <column name="DELETE_USER_ID" type="bigint"/>
            <column name="DELETE_USER_NAME" type="varchar(255)"/>
            <column name="DELETE_USER_FULL_NAME" type="varchar(255)"/>
            <column name="DELETE_IP" type="varchar(128)"/>
            <column name="DELETED" type="boolean" defaultValue="false"/>

            <column name="ROW_LOG_ID" type="varchar(255)"/>
            <!-->>>>>>>>>>>>>>>>>>>>>>>公有属性结束>>>>>>>>>>>>>>>>>>>>>>>-->
            <column name="BOOK_NAME" type="varchar(255)"/>
            <column name="INTRODUCTION" type="varchar(1024)"/>
            <column name="PRICE" type="number(19, 6)"/>
        </createTable>
    </changeSet>
    <changeSet author="system" id="DEMO_BOOK_ADD_INDEX_NAME">
        <createIndex indexName="IDX_DEMO_BOOK_NAME" tableName="DEMO_BOOK">
            <column name="BOOK_NAME"/>
        </createIndex>
    </changeSet>

</databaseChangeLog>

package com.ags.lumosframework.demo.impl.dao;

import org.springframework.stereotype.Repository;

import com.ags.lumosframework.demo.sdk.entity.BookEntity;
import com.ags.lumosframework.impl.base.dao.core.BaseEntityDao;

@Repository("bookDao")
public class BookDao extends BaseEntityDao<BookEntity> {}

package com.ags.lumosframework.demo.sdk.handler;

import com.ags.lumosframework.demo.sdk.entity.BookEntity;
import com.ags.lumosframework.sdk.base.handler.api.IBaseEntityHandler;
import com.ags.lumosframework.sdk.dubbo.RpcSupport;

@RpcSupport
public interface IBookHandler extends IBaseEntityHandler<BookEntity> {

}

package com.ags.lumosframework.demo.impl.handler;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;

import com.ags.lumosframework.demo.impl.dao.BookDao;
import com.ags.lumosframework.demo.sdk.entity.BookEntity;
import com.ags.lumosframework.demo.sdk.handler.IBookHandler;
import com.ags.lumosframework.impl.base.dao.core.BaseEntityDao;
import com.ags.lumosframework.impl.base.handler.AbstractBaseEntityHandler;

@Service
@Primary
public class BookHandler extends AbstractBaseEntityHandler<BookEntity> implements IBookHandler {

    @Autowired
    private BookDao bookDao;

    @Override
    protected BaseEntityDao<BookEntity> getDao() {
        return bookDao;
    }

}

package com.ags.lumosframework.demo.sdk.service;

import com.ags.lumosframework.demo.sdk.domain.Book;
import com.ags.lumosframework.sdk.base.service.api.IBaseDomainObjectService;

public interface IBookService extends IBaseDomainObjectService<Book> {

}

package com.ags.lumosframework.demo.sdk.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;

import com.ags.lumosframework.demo.sdk.domain.Book;
import com.ags.lumosframework.demo.sdk.entity.BookEntity;
import com.ags.lumosframework.demo.sdk.handler.IBookHandler;
import com.ags.lumosframework.demo.sdk.service.IBookService;
import com.ags.lumosframework.sdk.base.handler.api.IBaseEntityHandler;
import com.ags.lumosframework.sdk.base.service.AbstractBaseDomainObjectService;

@Service
@Primary
public class BookService extends AbstractBaseDomainObjectService<Book, BookEntity> implements IBookService {

    @Autowired
    private IBookHandler bookHandler;

    @Override
    protected IBaseEntityHandler<BookEntity> getEntityHandler() {
        return bookHandler;
    }

}

package com.ags.lumosframework.web.ui;

import com.ags.lumosframework.web.vaadin.base.BaseUIHasMenu;
import com.ags.lumosframework.web.vaadin.base.annotation.WebEntry;
import com.vaadin.annotations.Theme;
import com.vaadin.spring.annotation.SpringUI;

@WebEntry(shortCaption = "Demo", longCaption = "示例", description = "This is a demo module", iconPath = "images/mes.png",
    order = 1)
@SpringUI(path = "Demo")
@Theme("light")
public class DemoUI extends BaseUIHasMenu {

    @Override
    protected void setTitle() {

    }
}

package com.ags.lumosframework.web.ui.view.demo;

import com.ags.lumosframework.common.exception.PlatformException;
import com.ags.lumosframework.demo.sdk.domain.Book;
import com.ags.lumosframework.demo.sdk.service.IBookService;
import com.ags.lumosframework.web.common.i18.I18NUtility;
import com.ags.lumosframework.web.common.i18.I18Support;
import com.ags.lumosframework.web.common.security.annotation.Secured;
import com.ags.lumosframework.web.constant.DemoPermissionConstants;
import com.ags.lumosframework.web.ui.DemoUI;
import com.ags.lumosframework.web.vaadin.base.BaseView;
import com.ags.lumosframework.web.vaadin.base.ConfirmDialog;
import com.ags.lumosframework.web.vaadin.base.ConfirmResult;
import com.ags.lumosframework.web.vaadin.base.CoreTheme;
import com.ags.lumosframework.web.vaadin.base.annotation.Menu;
import com.ags.lumosframework.web.vaadin.component.paginationobjectlist.IDomainObjectGrid;
import com.ags.lumosframework.web.vaadin.component.paginationobjectlist.PaginationDomainObjectList;
import com.vaadin.icons.VaadinIcons;
import com.vaadin.navigator.ViewChangeListener;
import com.vaadin.spring.annotation.SpringView;
import com.vaadin.ui.Button;
import com.vaadin.ui.Component;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.VerticalLayout;
import org.springframework.beans.factory.annotation.Autowired;

import java.text.NumberFormat;
import java.util.Optional;

@Menu(caption = "Book", captionI18NKey = "demo.book.view.caption", iconPath = "images/icon/text-blob.png", order = 0)
@SpringView(name = "Book", ui = DemoUI.class)
public class BookView extends BaseView implements Button.ClickListener {

    /**
     *
     */
    private static final long serialVersionUID = 8141409383766735767L;

    @Secured(DemoPermissionConstants.BOOK_ADD)
    @I18Support(caption = "Add", captionKey = "common.add")
    private Button btnAdd = new Button();

    @Secured(DemoPermissionConstants.BOOK_EDIT)
    @I18Support(caption = "Edit", captionKey = "common.edit")
    private Button btnEdit = new Button();

    @Secured(DemoPermissionConstants.BOOK_DELETE)
    @I18Support(caption = "Delete", captionKey = "common.delete")
    private Button btnDelete = new Button();

    @Secured(DemoPermissionConstants.BOOK_REFRESH)
    @I18Support(caption = "Refresh", captionKey = "common.refresh")
    private Button btnRefresh = new Button();

    private Button[] btns = new Button[] {btnAdd, btnEdit, btnDelete, btnRefresh};

    private HorizontalLayout hlToolBox = new HorizontalLayout();

    private IDomainObjectGrid<Book> objectGrid = new PaginationDomainObjectList<>();

    @Autowired
    private AddBookDialog addBookDialog;

    @Autowired
    private IBookService bookService;

    public BookView() {
        VerticalLayout vlRoot = new VerticalLayout();
        vlRoot.setMargin(false);
        vlRoot.setSizeFull();

        hlToolBox.setWidth("100%");
        hlToolBox.addStyleName(CoreTheme.TOOLBOX);
        hlToolBox.setMargin(true);
        vlRoot.addComponent(hlToolBox);
        HorizontalLayout hlTempToolBox = new HorizontalLayout();
        hlToolBox.addComponent(hlTempToolBox);
        for (Button btn : btns) {
            hlTempToolBox.addComponent(btn);
            btn.addClickListener(this);
            btn.setDisableOnClick(true);
        }
        btnAdd.setIcon(VaadinIcons.PLUS);
        btnEdit.setIcon(VaadinIcons.EDIT);
        btnDelete.setIcon(VaadinIcons.TRASH);
        btnRefresh.setIcon(VaadinIcons.REFRESH);

        objectGrid.addColumn(Book::getName).setCaption(I18NUtility.getValue("demo.book.name", "Name"));
        objectGrid.addColumn(Book::getIntroduction)
            .setCaption(I18NUtility.getValue("demo.book.introduction", "Introduction"));
        objectGrid.addColumn(source -> {
            double price = source.getPrice();
            return NumberFormat.getInstance().format(price);
        }).setCaption(I18NUtility.getValue("demo.book.price", "Price"));
        objectGrid.setObjectSelectionListener(event -> {
            setButtonStatus(event.getFirstSelectedItem());
        });
        vlRoot.addComponents((Component)objectGrid);
        vlRoot.setExpandRatio((Component)objectGrid, 1);

        this.setSizeFull();
        this.setCompositionRoot(vlRoot);
    }

    private void setButtonStatus(Optional<Book> optional) {
        boolean enable = optional.isPresent();
        btnEdit.setEnabled(enable);
        btnDelete.setEnabled(enable);
    }

    @Override
    protected void init() {
        objectGrid.setServiceClass(IBookService.class);
    }

    @Override
    public void enter(ViewChangeListener.ViewChangeEvent event) {
        setButtonStatus(Optional.empty());
        objectGrid.refresh();
    }

    @Override
    public void buttonClick(Button.ClickEvent event) {
        Button button = event.getButton();
        button.setEnabled(true);
        if (btnAdd.equals(button)) {
            addBookDialog.setObject(null);
            addBookDialog.show(getUI(), result -> {
                if (ConfirmResult.Result.OK.equals(result.getResult())) {
                    objectGrid.refresh();
                }
            });
        } else if (btnEdit.equals(button)) {
            Book book = (Book)objectGrid.getSelectedObject();
            addBookDialog.setObject(book);
            addBookDialog.show(getUI(), result -> {
                if (ConfirmResult.Result.OK.equals(result.getResult())) {
                    Book temp = (Book)result.getObj();
                    objectGrid.refresh(temp);
                }
            });
        } else if (btnDelete.equals(button)) {
            ConfirmDialog.show(getUI(),
                I18NUtility.getValue("common.suretodelete", "Are you sure to delete the selected item?"), result -> {
                    if (ConfirmResult.Result.OK.equals(result.getResult())) {
                        try {
                            bookService.delete((Book)objectGrid.getSelectedObject());
                        } catch (PlatformException e) {
                            notificationError("Common.RelationShipCheckFailed", e.getMessage());
                            return;
                        }
                        objectGrid.refresh();
                    }
                });
        } else if (btnRefresh.equals(button)) {
            objectGrid.refresh();
        }
    }
}

package com.ags.lumosframework.web.ui.view.demo;

import org.springframework.context.annotation.Scope;

import com.ags.lumosframework.demo.sdk.domain.Book;
import com.ags.lumosframework.demo.sdk.service.IBookService;
import com.ags.lumosframework.web.common.i18.I18NUtility;
import com.ags.lumosframework.web.common.i18.I18Support;
import com.ags.lumosframework.web.vaadin.base.BaseDialog;
import com.ags.lumosframework.web.vaadin.base.DialogCallBack;
import com.ags.lumosframework.web.vaadin.constants.VaadinCommonConstant;
import com.vaadin.data.Binder;
import com.vaadin.data.converter.StringToDoubleConverter;
import com.vaadin.data.validator.DoubleRangeValidator;
import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.ui.Component;
import com.vaadin.ui.TextField;
import com.vaadin.ui.UI;
import com.vaadin.ui.VerticalLayout;

@SpringComponent
@Scope("prototype")
public class AddBookDialog extends BaseDialog {

    @I18Support(caption = "Name", captionKey = "demo.book.name")
    private TextField tfName = new TextField();

    @I18Support(caption = "Introduction", captionKey = "demo.book.introduction")
    private TextField tfIntroduction = new TextField();

    @I18Support(caption = "Price", captionKey = "demo.book.price")
    private TextField tfPrice = new TextField();

    private Binder<Book> binder = new Binder<>();

    private String caption;

    private Book book;

    private IBookService bookService;

    public AddBookDialog(IBookService bookService) {
        this.bookService = bookService;
    }

    public void setObject(Book book) {
        String captionName = I18NUtility.getValue("demo.book.caption", "Book");
        if (book == null) {
            this.caption = I18NUtility.getValue("common.new", "New", captionName);
            book = new Book();
        } else {
            this.caption = I18NUtility.getValue("common.modify", "Modify", captionName);
        }
        this.book = book;
        binder.readBean(book);
    }

    @Override
    public void show(UI parentUI, DialogCallBack callBack) {
        setHeightUnDefinedMode();
        showDialog(parentUI, caption, VaadinCommonConstant.MEDIUM_DIALOG_WIDTH, null, false, true, callBack);
    }

    @Override
    protected void initUIData() {
        binder.forField(tfName)
            .asRequired(I18NUtility.getValue("common.requiredfilednotempty", "Required filed cannot be empty"))
            .bind(Book::getName, Book::setName);
        binder.bind(tfIntroduction, Book::getIntroduction, Book::setIntroduction);
        binder.forField(tfPrice)
            .withConverter(
                new StringToDoubleConverter(I18NUtility.getValue("Common.OnlyFloatAllowed", "Only float is allowed")))
            .withValidator(new DoubleRangeValidator(
                I18NUtility.getValue("Common.MustEqualOrLargerThan0", "Must equals or larger than 0"), 0D,
                Double.MAX_VALUE))
            .bind(Book::getPrice, Book::setPrice);
    }

    @Override
    protected void okButtonClicked() throws Exception {
        binder.writeBean(book);
        Book save = bookService.save(book);
        result.setObj(save);
    }

    @Override
    protected void cancelButtonClicked() {}

    @Override
    protected Component getDialogContent() {
        VerticalLayout vlContent = new VerticalLayout();
        vlContent.setSizeFull();

        tfName.setWidth("100%");
        tfIntroduction.setWidth("100%");
        tfPrice.setWidth("100%");

        vlContent.addComponents(tfName, tfIntroduction, tfPrice);
        return vlContent;
    }

}

package com.ags.lumosframework.web.constant;

public class DemoPermissionConstants {

    public static final String BOOK_ADD = "demo.book.add";
    public static final String BOOK_EDIT = "demo.book.edit";
    public static final String BOOK_DELETE = "demo.book.delete";
    public static final String BOOK_REFRESH = "demo.book.refresh";

}

@Secured(DemoPermissionConstants.BOOK_ADD)

<?xml version="1.1" encoding="UTF-8" standalone="no"?>
<databaseChangeLog
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
        xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.6.xsd">

    <changeSet id="INIT_PERMISSION_DATA" author="system">
        <validCheckSum>any</validCheckSum>
        <insert tableName="SYS_PERMISSION">
            <column name="ID" valueNumeric="1000"/>
            <column name="COMPANY_ID" valueNumeric="-1"/>
            <column name="CREATE_TIME" valueDate="2019-06-01"/>
            <column name="CREATE_USER_ID" valueNumeric="1"/>
            <column name="CREATE_USER_NAME" value="admin"/>
            <column name="CREATE_USER_FULL_NAME" value="admin"/>
            <column name="DTS_CREATION_BID" valueNumeric="-1"/>
            <column name="LM_TIME" valueDate="2019-06-01"/>
            <column name="LM_USER_ID" valueNumeric="-1"/>
            <column name="LM_USER_NAME" value="admin"/>
            <column name="LM_USER_FULL_NAME" value="admin"/>
            <column name="DTS_MODIFIED_BID" valueNumeric="-1"/>
            <column name="DELETE_USER_ID" valueNumeric="-1"/>
            <column name="DELETED" valueBoolean="false"/>

            <column name="CATEGORY" value="Book"/>
            <column name="NAME" value="book.add"/>
            <column name="NAME_KEY" value="permission.book.add"/>
            <column name="SYSTEM_DEFINED" valueBoolean="true"/>
            <column name="MODULE" value="Demo"/>
        </insert>
        <insert tableName="SYS_PERMISSION">
            <column name="ID" valueNumeric="1001"/>
            <column name="COMPANY_ID" valueNumeric="-1"/>
            <column name="CREATE_TIME" valueDate="2019-06-01"/>
            <column name="CREATE_USER_ID" valueNumeric="1"/>
            <column name="CREATE_USER_NAME" value="admin"/>
            <column name="CREATE_USER_FULL_NAME" value="admin"/>
            <column name="DTS_CREATION_BID" valueNumeric="-1"/>
            <column name="LM_TIME" valueDate="2019-06-01"/>
            <column name="LM_USER_ID" valueNumeric="-1"/>
            <column name="LM_USER_NAME" value="admin"/>
            <column name="LM_USER_FULL_NAME" value="admin"/>
            <column name="DTS_MODIFIED_BID" valueNumeric="-1"/>
            <column name="DELETE_USER_ID" valueNumeric="-1"/>
            <column name="DELETED" valueBoolean="false"/>

            <column name="CATEGORY" value="Book"/>
            <column name="NAME" value="book.edit"/>
            <column name="NAME_KEY" value="permission.book.edit"/>
            <column name="SYSTEM_DEFINED" valueBoolean="true"/>
            <column name="MODULE" value="Demo"/>
        </insert>
        <insert tableName="SYS_PERMISSION">
            <column name="ID" valueNumeric="1002"/>
            <column name="COMPANY_ID" valueNumeric="-1"/>
            <column name="CREATE_TIME" valueDate="2019-06-01"/>
            <column name="CREATE_USER_ID" valueNumeric="1"/>
            <column name="CREATE_USER_NAME" value="admin"/>
            <column name="CREATE_USER_FULL_NAME" value="admin"/>
            <column name="DTS_CREATION_BID" valueNumeric="-1"/>
            <column name="LM_TIME" valueDate="2019-06-01"/>
            <column name="LM_USER_ID" valueNumeric="-1"/>
            <column name="LM_USER_NAME" value="admin"/>
            <column name="LM_USER_FULL_NAME" value="admin"/>
            <column name="DTS_MODIFIED_BID" valueNumeric="-1"/>
            <column name="DELETE_USER_ID" valueNumeric="-1"/>
            <column name="DELETED" valueBoolean="false"/>

            <column name="CATEGORY" value="Book"/>
            <column name="NAME" value="book.delete"/>
            <column name="NAME_KEY" value="permission.book.delete"/>
            <column name="SYSTEM_DEFINED" valueBoolean="true"/>
            <column name="MODULE" value="Demo"/>
        </insert>
        <insert tableName="SYS_PERMISSION">
            <column name="ID" valueNumeric="1003"/>
            <column name="COMPANY_ID" valueNumeric="-1"/>
            <column name="CREATE_TIME" valueDate="2019-06-01"/>
            <column name="CREATE_USER_ID" valueNumeric="1"/>
            <column name="CREATE_USER_NAME" value="admin"/>
            <column name="CREATE_USER_FULL_NAME" value="admin"/>
            <column name="DTS_CREATION_BID" valueNumeric="-1"/>
            <column name="LM_TIME" valueDate="2019-06-01"/>
            <column name="LM_USER_ID" valueNumeric="-1"/>
            <column name="LM_USER_NAME" value="admin"/>
            <column name="LM_USER_FULL_NAME" value="admin"/>
            <column name="DTS_MODIFIED_BID" valueNumeric="-1"/>
            <column name="DELETE_USER_ID" valueNumeric="-1"/>
            <column name="DELETED" valueBoolean="false"/>

            <column name="CATEGORY" value="Book"/>
            <column name="NAME" value="book.refresh"/>
            <column name="NAME_KEY" value="permission.book.refresh"/>
            <column name="SYSTEM_DEFINED" valueBoolean="true"/>
            <column name="MODULE" value="Demo"/>
        </insert>
    </changeSet>

</databaseChangeLog>

demo.book.view.caption=书籍
demo.book.caption=书籍
demo.book.name=书名
demo.book.introduction=简介
demo.book.price=价格

package com.ags.lumosframework.web.i18n;

import org.springframework.stereotype.Component;

import com.ags.lumosframework.web.common.i18.I18NProvider;

@Component
public class DemoI18NProvider implements I18NProvider {

    @Override
    public String[] getBaseNames() {
        return new String[] {"locale/Demo_I18_Normal"};
    }

    @Override
    public int getPriority() {
        return 0;
    }

}

package com.ags.lumosframework.web.common.i18;

public interface I18NProvider {

    /**
     * 返回该模块的国际化文件的名称。 该国际化文件一般放在 maven 项目的{reource_folder}下面
     *
     * @return
     */
    String[] getBaseNames();

    /**
     * 返回该模块的国际化文件的优先级，低优先级的会被高优先级的覆盖掉。
     *
     * @return
     */
    int getPriority();

}

public class UserCEF {
    public static final String USER_CF_USED_NAME = "USED_NAME";
    public static final String USER_CF_AGE = "AGE";
    public static final String USER_CF_BIRTHDAY = "BIRTHDAY";
}

user.setCEF(UserCEF.USER_CF_USED_NAME, "张三");
userService.save(user);

package com.ags.lumosframework.doc.demo.customizedobject.domain;

import java.time.ZonedDateTime;

import com.ags.lumosframework.sdk.base.domain.CustomizedObjectSupport;
import com.ags.lumosframework.sdk.base.entity.IDynamicEntity;

public class Person extends CustomizedObjectSupport {

    public static final String TABLE_NAME = "PERSON";
    public static final String NAME = "NAME";
    public static final String AGE = "AGE";
    public static final String BIRTHDAY = "BIRTHDAY";

    public Person() {
        super(TABLE_NAME);
    }

    public Person(IDynamicEntity dynamicEntity) {
        super(dynamicEntity);
    }

    public String getPersonName() {
        return getAsString(NAME);
    }

    public void setPersonName(String name) {
        set(NAME, name);
    }

    public int getAge() {
        return getAsInt(AGE) == null ? 0 : getAsInt(AGE);
    }

    public void setAge(int age) {
        set(AGE, age);
    }

    public ZonedDateTime getBirthday() {
        return getAsZonedDateTime(BIRTHDAY);
    }

    public void setBirthday(ZonedDateTime birthday) {
        set(BIRTHDAY, birthday);
    }

}

public void setUser(User user) {
    if (user != null) {
        set(ASSIGN_USER, user.getId());
    } else {
        set(ASSIGN_USER, null);
    }
}

package com.ags.lumosframework.sdk.base.entity;

import java.time.ZonedDateTime;

public interface IBaseEntity extends ISetDataId, IGetData {

    void setCompanyId(long companyId);

    void setPlatformId(String platformId);

    void setCreateTime(ZonedDateTime createTime);

    void setCreateUserId(long createUserId);

    void setCreateUserName(String createUserName);

    void setCreateUserFullName(String createUserFullName);

    void setCreateIp(String createIp);

    /**
     * 内部使用
     *
     * @return
     */
    void setCreateBid(long creationBid);

    void setLastModifyTime(ZonedDateTime lastModifyTime);

    void setLastModifyUserId(long lastModifyUserId);

    void setLastModifyUserName(String lastModifyUserName);

    void setModifyBid(long modifyBid);

    void setRowLogId(String rowLogId);

    void setLastModifyUserFullName(String lastModifyUserFullName);

    void setLastModifyIp(String lastModifyIp);

    void setDeleteTime(ZonedDateTime deleteTime);

    void setDeleteUserId(long deleteUserId);

    void setDeleteUserName(String deleteUserName);

    void setDeleteIp(String deleteIp);

    void setDeleted(boolean deleted);

    void setDeleteUserFullName(String deleteUserFullName);
}

package com.ags.lumosframework.doc.demo.customizedobject.service;

import com.ags.lumosframework.doc.demo.customizedobject.domain.Person;
import com.ags.lumosframework.sdk.base.service.api.ICustomizedObjectSupportService;

public interface IPersonService extends ICustomizedObjectSupportService<Person> {}

package com.ags.lumosframework.doc.demo.customizedobject.service.impl;

import com.ags.lumosframework.sdk.base.service.AbstractCustomizedObjectSupportService;
import org.springframework.stereotype.Service;

import com.ags.lumosframework.doc.demo.customizedobject.domain.Person;
import com.ags.lumosframework.doc.demo.customizedobject.service.IPersonService;

@Service
public class PersonService extends AbstractCustomizedObjectSupportService<Person> implements IPersonService {

    @Override
    public String getTableName() {
        return Person.TABLE_NAME;
    }
}

package com.ags.lumosframework.sdk.base.service.api;

import com.ags.lumosframework.sdk.base.domain.ICustomizedObjectSupport;
import com.ags.lumosframework.sdk.base.filter.DynamicEntityFilter;

import java.util.List;

/**
 * 用于自定义表二次开发时自定义对象的service接口
 *
 * @param <T>
 */
public interface ICustomizedObjectSupportService<T extends ICustomizedObjectSupport> extends IBaseService {

    /**
     * 添加自定义对象
     *
     * @param obj
     * @return
     */
    T save(T obj);

    /**
     * 添加多个自定义对象
     *
     * @param objs
     */
    void saveAll(List<T> objs);

    /**
     * 根据id删除自定义对象
     *
     * @param objId
     */
    void deleteById(long objId);

    /**
     * 删除一个自定义对象
     *
     * @param obj
     */
    void delete(T obj);

    /**
     * 根据id查询一个自定义对象
     *
     * @param id
     * @return
     */
    T getById(long id);

    /**
     * 根据DynamicEntityFilter条件查询自定义对象
     *
     * @param entityFilter
     * @return
     */
    T getByFilter(DynamicEntityFilter entityFilter);

    /**
     * 查询所有自定义对象
     *
     * @return
     */
    List<T> list();

    /**
     * 根据条件查询自定义对象列表
     *
     * @param entityFilter
     * @return
     */
    List<T> listByFilter(DynamicEntityFilter entityFilter);

    /**
     * 查询数量
     *
     * @param entityFilter
     * @return
     */
    int countByFilter(DynamicEntityFilter entityFilter);

    String getTableName();
}

public interface IBaseEntityHandler<T extends IBaseEntity> extends IBaseHandler {

    //key的实际值为id=????
    @CacheDelete(key = "'id=' + #entity.id")
    T save(T entity);

    void saveAll(List<T> entities);

    @CacheDelete(key = "'id=' + #t.id")
    void delete(T t);

    @CacheDelete(key = "'id=' + #entityId")
    void deleteById(long entityId);

    void deleteByIds(List<Long> entityIds);

    @CacheAdd(key = "'id=' + #id")
    T getById(long id);

package com.ags.lumosframework.common.cache;

public interface CacheManager {

    /**
     * 根据名称查询或者创建对应的缓存对象
     *
     * @param name
     * @return
     */
    Cache getOrCreateCache(String name);

    /**
     * 根据名称查询或者创建对应的缓存对象
     *
     * @param name
     * @param config
     *            创建缓存时使用的配置对象
     * @return
     */
    Cache getOrCreateCache(String name, Object config);

    /**
     * 清空缓存下的所有记录
     *
     * @param name
     */
    void clearCache(String name);

}

/*
 * Copyright 2002-2019 the original author or authors.
 *
 * 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
 *
 * https://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 com.ags.lumosframework.common.cache;

import java.util.Optional;

public interface Cache {

    /**
     * 获取缓存的名字
     *
     * @return
     */
    String getName();

    Object getNativeCache();

    /**
     * 根据key获取缓存中的记录
     *
     * @param key
     * @return
     */
    Optional<Object> get(String key);

    /**
     * 返回对应类型的缓存记录
     *
     * @param key
     * @param type
     * @param <T>
     * @return
     */
    <T> Optional<T> get(String key, Class<T> type);

    /**
     * 添加一个缓存记录
     *
     * @param key
     * @param value
     * @param aliasNames
     *            缓存记录key的别名
     */
    void put(String key, Object value, String... aliasNames);

    /**
     * 先移除记录，再更新缓存
     *
     * @param key
     * @param value
     * @param aliasNames
     */
    void evictAndPut(String key, Object value, String... aliasNames);

    /**
     * 移除缓存记录
     *
     * @param key
     */
    void evict(String key);

    /**
     * 清空缓存
     */
    void clear();

}

package com.ags.lumosframework.common.parameter;

import com.ags.lumosframework.common.parameter.value.NumberRadixValues;
import com.ags.lumosframework.common.parameter.value.PadPositionValues;

public enum CommonParameterDefs implements IParameterDef {
    /**
     * 固定值
     */
    FIXED_VALUE("FIXED_VALUE", "FIXED_VALUE", "parameter.def.fixed-value", ParameterType.String),
    /**
     * 自定义值
     */
    CUSTOMIZED_VALUE("CUSTOMIZED_VALUE", "CUSTOMIZED_VALUE", "parameter.def.customized-value", ParameterType.String),

    /**
     * 流水号（一般表示自增的数值类型）
     */
    SERIAL_NUMBER("SERIAL_NUMBER", "SERIAL_NUMBER", "parameter.def.serial-number", ParameterType.Number),
    /**
     * 日
     */
    DAY("DAY", "DAY", "parameter.def.day", ParameterType.Number),
    /**
     * 月
     */
    MONTH("MONTH", "MONTH", "parameter.def.month", ParameterType.Number),
    /**
     * 年
     */
    YEAR("YEAR", "YEAR", "parameter.def.year", ParameterType.Number),

    /**
     * 原始进制，（格式化器使用的参数）
     */
    ORIGIN_RADIX("ORIGIN_RADIX", "ORIGIN_RADIX", "parameter.def.origin-radix", ParameterType.ComplexSingleSelect,
        new IParameterValue[] {NumberRadixValues.RADIX10, NumberRadixValues.RADIX16, NumberRadixValues.RADIX34,
            NumberRadixValues.RADIX36},
        NumberRadixValues.RADIX10),

    /**
     * 目标进制，（格式化器使用的参数）
     */
    TARGET_RADIX("TARGET_RADIX", "TARGET_RADIX", "parameter.def.target-radix", ParameterType.ComplexSingleSelect,
        new IParameterValue[] {NumberRadixValues.RADIX10, NumberRadixValues.RADIX16, NumberRadixValues.RADIX34,
            NumberRadixValues.RADIX36}),
    /**
     * 左补齐还是又补齐，（格式化器使用的参数）
     */
    PAD_POSITION("PAD_POSITION", "PAD_POSITION", "parameter.def.pad-position", ParameterType.ComplexSingleSelect,
        new IParameterValue[] {PadPositionValues.LEFT, PadPositionValues.RIGHT}, PadPositionValues.LEFT),
    /**
     * 补齐长度，（格式化器使用的参数）
     */
    PAD_LENGTH("PAD_LENGTH", "PAD_LENGTH", "parameter.def.pad-length", ParameterType.Number),
    /**
     * 补齐的占位符，（格式化器使用的参数）
     */
    PAD_PLACE_HOLDER("PAD_PLACE_HOLDER", "PAD_PLACE_HOLDER", "parameter.def.pad-place-holder", ParameterType.Char),;

    String key;
    String name;
    String nameI18NKey;
    ParameterType parameterType;
    IParameterValue[] parameterValues;
    IParameterValue defaultParameterValue;

    CommonParameterDefs(String key, String name, String nameI18NKey, ParameterType parameterType) {
        this.key = key;
        this.name = name;
        this.nameI18NKey = nameI18NKey;
        this.parameterType = parameterType;
    }

    CommonParameterDefs(String key, String name, String nameI18NKey, ParameterType parameterType,
        IParameterValue[] parameterValues) {
        this(key, name, nameI18NKey, parameterType);
        this.parameterValues = parameterValues;
    }

    CommonParameterDefs(String key, String name, String nameI18NKey, ParameterType parameterType,
        IParameterValue[] parameterValues, IParameterValue defaultParameterValue) {
        this(key, name, nameI18NKey, parameterType);
        this.parameterValues = parameterValues;
        this.defaultParameterValue = defaultParameterValue;
    }

    @Override
    public String getKey() {
        return key;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getNameI18NKey() {
        return nameI18NKey;
    }

    @Override
    public ParameterType getType() {
        return parameterType;
    }

    @Override
    public IParameterValue[] getParameterValues() {
        return parameterValues;
    }

    @Override
    public IParameterValue getDefaultParameterValue() {
        return defaultParameterValue;
    }
}

package com.ags.lumosframework.sdk.sequence;

import java.util.ArrayList;
import java.util.List;

import com.ags.lumosframework.common.parameter.CommonParameterDefs;
import com.ags.lumosframework.common.parameter.IParameterDef;

public interface ISequenceType {

    /**
     * sequence名字
     *
     * @return
     */
    String getName();

    /**
     * sequence名字国际化key
     *
     * @return
     */
    String getNameI18NKey();

    List<IParameterDef> getParameterDefs();

    /**
     * 是否支持扩展属性
     *
     * @return
     */
    boolean isSupportCustomizedParam();

    /**
     * 默认提供的参数列表
     *
     * @return
     */
    default List<IParameterDef> getDefaultParameterDefs() {
        List<IParameterDef> parameterDefList = new ArrayList<>();
        parameterDefList.add(CommonParameterDefs.YEAR);
        parameterDefList.add(CommonParameterDefs.MONTH);
        parameterDefList.add(CommonParameterDefs.DAY);
        parameterDefList.add(CommonParameterDefs.SERIAL_NUMBER);
        parameterDefList.add(CommonParameterDefs.FIXED_VALUE);
        return parameterDefList;
    }
}

package com.ags.lumosframework.sdk.handler.api;

import com.ags.lumosframework.common.cache.annotation.CacheAdd;
import com.ags.lumosframework.sdk.base.handler.api.IBaseEntityHandler;
import com.ags.lumosframework.sdk.dubbo.RpcSupport;
import com.ags.lumosframework.sdk.entity.SequenceDefEntity;

import java.util.List;
import java.util.Map;

@RpcSupport
public interface ISequenceDefHandler extends IBaseEntityHandler<SequenceDefEntity> {

    /**
     * @param sequenceDef
     *            上文添加的序列号定义
     * @param params
     *            参数值，与上文添加的参数定义对应，部分参数字段可以不需要传入（年月日，序列号）
     * @return 返回生成的序列号
     */
    String next(SequenceDefEntity sequenceDef, Map<String, Object> params);

    /**
     * @param sequenceDef
     *            上文添加的序列号定义
     * @param params
     *            参数值，与上文添加的参数定义对应，部分参数字段可以不需要传入（年月日，序列号）
     * @param count
     *            生成序列号的数目
     * @return 返回生成的序列号列表
     */
    List<String> next(SequenceDefEntity sequenceDef, Map<String, Object> params, int count);

    /**
     * @param sequenceDef
     *            上文添加的序列号定义
     * @param params
     *            参数值，可以只包含参数定义中勾选了重置的参数，因为只查询，不生成
     * @return 返回当前的值
     */
    long current(SequenceDefEntity sequenceDef, Map<String, Object> params);

    @CacheAdd(key = "'sequenceName=' + #sequenceName")
    SequenceDefEntity getByName(String sequenceName);

    /**
     * 根据sequenceType查询对应的序列号定义，多个的情况下只返回
     *
     * @param sequenceType
     * @return
     */
    SequenceDefEntity getDefaultForSequenceType(String sequenceType);

    /**
     * 获取所有的有效序列号定义
     *
     * @return 序列号定义集合
     */
    List<SequenceDefEntity> listSequenceDefs();

    /**
     * 根据序列号类型获取有效的序列号定义集合
     * @param sequenceType
     * @return
     */
    List<SequenceDefEntity> listSequenceDefsBySequenceType(String sequenceType);
}

package com.ags.lumosframework.web.vaadin.base.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface WebEntry {

    /**
     * 应用所属的应用分组，如管理相关，运行期相关等，可以为空
     *
     * @return
     */
    String groupName() default "";

    /**
     * 在首页显示时使用的icon路径，该路径可以为网络路径，也可以是项目中的相对路径
     *
     * @return
     */
    String iconPath() default "";

    /**
     * 在首页显示时使用的icon路径，该路径可以为网络路径，也可以是项目中的相对路径
     *
     * @return
     */
    String[] backgroundPath() default {"platform/img/index/bg1.png", "platform/img/index/bg2.png"};

    /**
     * 在首页显示时的css样式信息
     *
     * @return
     */
    String cssClass() default "";

    /**
     * 首页显示该应用时的标题信息
     *
     * @return
     */
    String shortCaption() default "";

    /**
     * 首页显示时标题的国际化信息
     *
     * @return
     */
    String shortCaptionI18NKey() default "";

    /**
     * 首页显示该应用的时候，可以显示一段描述
     *
     * @return
     */
    String longCaption() default "";

    /**
     * 首页显示该应用的时候，可以显示一段描述的国际化信息
     *
     * @return
     */
    String longCaptionI18NKey() default "";

    /**
     * 首页显示该应用的时候，可以显示一段描述
     *
     * @return
     */
    String description() default "";

    /**
     * 首页显示该应用的时候，可以显示一段描述的国际化信息
     *
     * @return
     */
    String descriptionI18NKey() default "";

    /**
     * 显示在首页的排序，数值越小，优先级越高，反之亦然
     *
     * @return
     */
    int order() default 0;

    /**
     * 如果该应用在进入页面后有菜单，并且菜单有分组信息，那么可以预先加载分组信息.
     * <p>
     * 这个分组信息也可以不在此时定义，后续依然可以通过扩展接口的方式实现
     *
     * @return
     */
    MenuGroup[] viewGroups() default {};
}

package com.ags.lumosframework.web.vaadin.base.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.PARAMETER})
public @interface MenuGroup {

    /**
     * 应用侧边栏分组信息的名称
     *
     * @return
     */
    String name();

    /**
     * 应用侧边栏的标题
     *
     * @return
     */
    String caption();

    /**
     * 应用侧边栏的标题的国际化信息
     *
     * @return
     */
    String captionI18NKey() default "";

    /**
     * 如果定义icon，那么该icon将显示在菜单分组信息的左侧
     *
     * @return
     */
    String iconPath();

    /**
     * 该菜单分组的排序，数值越小，越靠前
     *
     * @return
     */
    int order();
}

package com.ags.lumosframework.web.vaadin.ui.admin;

import com.ags.lumosframework.web.common.i18.I18NUtility;
import com.ags.lumosframework.web.common.security.annotation.Secured;
import com.ags.lumosframework.web.vaadin.base.BaseUIHasMenu;
import com.ags.lumosframework.web.vaadin.base.annotation.MenuGroup;
import com.ags.lumosframework.web.vaadin.base.annotation.WebEntry;
import com.ags.lumosframework.web.vaadin.constants.LumosConstants;
import com.ags.lumosframework.web.vaadin.constants.LumosPermissionConstants;
import com.vaadin.annotations.Theme;
import com.vaadin.server.Page;
import com.vaadin.spring.annotation.SpringUI;

@WebEntry(longCaption = "管理项", shortCaption = "Administration", shortCaptionI18NKey = "ui.administration",
    description = "For enterprise IT managers to perform system level management.",
    descriptionI18NKey = "Home.Page.Administration.Description", iconPath = "platform/img/index/icon_Administration.png",
    backgroundPath = {"platform/img/index/Administration1.png", "platform/img/index/Administration2.png"}, order = 400,
    viewGroups = {@MenuGroup(name = LumosConstants.ADMIN_OC_RELATED_Default, // oc相关
        captionI18NKey = LumosConstants.ADMIN_OC_RELATED_I18N, caption = LumosConstants.ADMIN_OC_RELATED_Default,
        iconPath = "", order = 0),
        @MenuGroup(name = LumosConstants.ADMIN_ADVANCED_SETTING_Default, // 高级设定
            captionI18NKey = LumosConstants.ADMIN_ADVANCED_SETTING_I18N,
            caption = LumosConstants.ADMIN_ADVANCED_SETTING_Default, iconPath = "", order = 1)})
@SpringUI(path = "administration")
@Secured(LumosPermissionConstants.ADMINISTRATION_MANAGE)
@Theme("light")
public class AdminUI extends BaseUIHasMenu {

    /**
     *
     */
    private static final long serialVersionUID = -8225969815229992750L;

    @Override
    protected void setTitle() {
        Page.getCurrent().setTitle(I18NUtility.getValue("ui.administration", "Administration"));
    }

}

package com.ags.lumosframework.web.vaadin.base.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface Menu {

    /**
     * 如果指定，将在把应用放在菜单时，自动寻找菜单分组放入
     *
     * @return
     */
    String groupName() default "";

    /**
     * 应用在菜单上显示的名称
     *
     * @return
     */
    String caption();

    /**
     * 应用在菜单上显示的名称的国际化信息
     *
     * @return
     */
    String captionI18NKey() default "";

    /**
     * 如果定义，将在菜单左侧显示icon
     *
     * @return
     */
    String iconPath();

    /**
     * 应用在菜单分组时的排序信息
     *
     * @return
     */
    int order();
}

@Menu(groupName = LumosConstants.ADMIN_OC_RELATED_Default, caption = "user", captionI18NKey = "admin.user",
    iconPath = "images/icon/user.png", order = 0)
@SpringView(name = "user", ui = AdminUI.class)
@Secured(LumosPermissionConstants.USER_MANEGE)
public class UserView extends BaseView implements Button.ClickListener, IFilterableView {

    /**
     *
     */
    private static final long serialVersionUID = -6316701858905840322L;

    @Secured(LumosPermissionConstants.USER_ADD)
    @I18Support(caption = "Add", captionKey = "common.add")
    private Button btnAdd = new Button();

    @Secured(LumosPermissionConstants.USER_EDIT)
    @I18Support(caption = "Edit", captionKey = "common.edit")
    private Button btnEdit = new Button();

    @Secured(LumosPermissionConstants.USER_RESET_PASSWORD)
    @I18Support(caption = "Reset Password", captionKey = "admin.user.resetpassword")
    private Button btnResetPassword = new Button();

package com.ags.lumosframework.web.vaadin.ui.report;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;

import com.ags.lumosframework.web.vaadin.base.CoreSideBar;
import com.ags.lumosframework.web.vaadin.constants.LumosConstants;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.vaadin.sliderpanel.SliderPanel;

import com.ags.lumosframework.common.constant.CommonConstants;
import com.ags.lumosframework.common.spring.BeanManager;
import com.ags.lumosframework.sdk.domain.I18NText;
import com.ags.lumosframework.sdk.domain.Permission;
import com.ags.lumosframework.sdk.domain.Report;
import com.ags.lumosframework.sdk.service.api.IReportService;
import com.ags.lumosframework.web.common.functionality.ApplicationInfo;
import com.ags.lumosframework.web.common.functionality.ApplicationManager;
import com.ags.lumosframework.web.common.functionality.ApplicationPageGroup;
import com.ags.lumosframework.web.common.functionality.ApplicationPageInfo;
import com.ags.lumosframework.web.common.i18.I18NUtility;
import com.ags.lumosframework.web.common.security.annotation.Secured;
import com.ags.lumosframework.web.common.security.annotation.SecuredInfo;
import com.ags.lumosframework.web.vaadin.base.BaseUIHasMenu;
import com.ags.lumosframework.web.vaadin.base.annotation.WebEntry;
import com.ags.lumosframework.web.vaadin.constants.LumosPermissionConstants;
import com.ags.lumosframework.web.vaadin.ui.report.customreport.IBirtReportView;
import com.vaadin.annotations.Theme;
import com.vaadin.server.Page;
import com.vaadin.server.VaadinRequest;
import com.vaadin.spring.annotation.SpringUI;

@WebEntry(longCaption = "报表", shortCaption = "Report", shortCaptionI18NKey = "Common.Report",
    description = "Visual Display and Individual Formulation of Data Statistical Statements.",
    descriptionI18NKey = "Home.Page.Report.Description", iconPath = "platform/img/index//icon_Report.png",
    backgroundPath = {"platform/img/index/Report1.png", "platform/img/index/Report2.png"}, order = 500)
@SpringUI(path = CommonConstants.REPORT)
@Secured(LumosPermissionConstants.REPORT_MANAGE1)
@Theme("light")
public class ReportUI extends BaseUIHasMenu {

    private static final long serialVersionUID = -552520960746758358L;

    protected SliderPanel sliderPanel;

    private SortedMap<ApplicationPageGroup, SortedSet<ApplicationPageInfo>> defaultMenuGroups = new TreeMap<>();

    @Override
    protected void setTitle() {
        Page.getCurrent().setTitle(I18NUtility.getValue("Common.Report", "Report"));
    }

    @Override
    protected void initSideBar() {

    }

    @Override
    protected void init(VaadinRequest request) {
        super.init(request);

        // bgtaskListener.putConsumer(MesConstants.REPORT +
        // Thread.currentThread().getId(), header);
        // sliderPanel = bgTaskPanel.getSliderPanel();
        // header.setBackgroundTaskBtnCallback(() -> {
        // if (sliderPanel != null) {
        // sliderPanel.expand();
        // }
        // });
        // mainCountent.addComponent(sliderPanel);

        addExtendMenuGroup();
    }

    private void addExtendMenuGroup() {
        ApplicationInfo appInfoByAppPath = ApplicationManager.getAppInfoByAppPath(CommonConstants.REPORT);
        SortedSet<ApplicationPageGroup> groups = ApplicationManager.getAppPageGroupsByApp(appInfoByAppPath);
        for (ApplicationPageGroup group : groups) {
            SortedSet<ApplicationPageInfo> pageInfos = ApplicationManager.getAppPageInfosByGroup(group);
            defaultMenuGroups.put(group, pageInfos);
        }

        // 用户自定义
        List<Report> list = BeanManager.getService(IReportService.class).list(0, Integer.MAX_VALUE);
        Collections.sort(list, new Comparator<Report>() {

            @Override
            public int compare(Report arg0, Report arg1) {
                return arg0.getOrder() - arg1.getOrder();
            }
        });

        // customizedMenuGroups.addAll(ApplicationManager.getAppPageGroupsByApp(appInfoByAppPath));
        int flag = 4;
        for (Report report : list) {
            String menuName = getMenuName(report);
            if (findDefaultPageGroup(menuName) == null) {
                String captionI18N = report.getCategoryI18N() == null ? "" : report.getCategoryI18N().getName();
                ApplicationPageGroup build =
                    ApplicationPageGroup.builder().applicationInfo(appInfoByAppPath).name(menuName)
                        .caption(report.getCategory()).captionI18NKey(captionI18N).order(++flag).active(false).build();
                defaultMenuGroups.put(build, new TreeSet<ApplicationPageInfo>());
            }
        }

        for (Report report : list) {
            ApplicationPageGroup apg1 = findDefaultPageGroup(getMenuName(report));
            if (apg1 != null) {
                SecuredInfo si = new SecuredInfo();
                Permission privilege = report.getPrivilege();
                si.setRequiredPermission(privilege == null ? "" : privilege.getName());
                I18NText menuCaptionI18N = report.getMenuCaptionI18N();
                String menuCaptionI18NId =
                    menuCaptionI18N == null ? report.getMenuCaption() : menuCaptionI18N.getName();
                ApplicationPageInfo pageInfo = ApplicationPageInfo.builder().caption(report.getMenuCaption())
                    .captionI18NKey(menuCaptionI18NId).applicationInfo(appInfoByAppPath).group(apg1)
                    .name(IBirtReportView.NAME + "/i18n=" + menuCaptionI18NId + ":" + report.getMenuCaption() + "&"
                        + IBirtReportView.REPORT_URL_KEY + "=" + report.getId())
                    .order(report.getOrder()).securedInfo(si).build();
                defaultMenuGroups.get(apg1).add(pageInfo);
            }
        }
        addPageGroup(defaultMenuGroups);
    }

    private String getMenuName(Report report) {
        I18NText text = report.getCategoryI18N();
        if (text != null) {
            if (LumosConstants.MENU_GROUP_PRODUCTION_KANBAN_DEFAULT_ZH.equals(text.getName())) {
                return LumosConstants.MENU_GROUP_PRODUCTION_KANBAN_DEFAULT;
            } else if (LumosConstants.MENU_GROUP_OUTPUT_DEFAULT_ZH.equals(text.getName())) {
                return LumosConstants.MENU_GROUP_OUTPUT_DEFAULT;
            } else if (LumosConstants.MENU_GROUP_WIP_DEFAULT_ZH.equals(text.getName())) {
                return LumosConstants.MENU_GROUP_WIP_DEFAULT;
            } else if (LumosConstants.MENU_GROUP_WORKORDER_DEFAULT_ZH.equals(text.getName())) {
                return LumosConstants.MENU_GROUP_WORKORDER_DEFAULT;
            } else if (LumosConstants.MENU_GROUP_QUALITY_DEFAULT_ZH.equals(text.getName())) {
                return LumosConstants.MENU_GROUP_QUALITY_DEFAULT;
            } else {
                return report.getCategoryI18NId() + "";
            }
        } else {
            return report.getCategory();
        }

    }

    private ApplicationPageGroup findDefaultPageGroup(String name) {
        for (ApplicationPageGroup apg : defaultMenuGroups.keySet()) {
            if (apg.getName().contentEquals(name)) {
                return apg;
            }
        }
        return null;
    }

}

UI.getCurrent().getNavigator().navigateTo(IOrderDetailView.NAME + "/" + IOrderDetailView.ORDER_NO
       + "=" + orderHeader.getOrderNo() +"&" + IOrderDetailView.VIEW_TYPE + "=" + ViewType.VIEW);

    private String getViewCaption(View view) {
        Class<? extends View> class1 = view.getClass();
        Menu annotation = class1.getAnnotation(Menu.class);
        String viewParameters = currentViewEvent.getParameters();
        //系统定义的菜单
        if (annotation != null) {
            if (viewParameters != null && !viewParameters.isEmpty()) {
                //以"&"为分隔符，分割ViewChangeEvent对象的parameters
                String[] split = viewParameters.split("&");
                //将第一个字符串再以"="为分隔符，分割字符串
                String[] keyValue = split[0].split("=");
                if (keyValue.length > 1) {
                    return I18NUtility.getValue(annotation.captionI18NKey(), annotation.caption()) + "-" + keyValue[1];
                } else {
                    return I18NUtility.getValue(annotation.captionI18NKey(), annotation.caption()) + "-" + keyValue[0];
                }
            }
            return I18NUtility.getValue(annotation.captionI18NKey(), annotation.caption());
        }
        //非系统定义的菜单
        else {
            if (viewParameters != null && !viewParameters.isEmpty()) {
                String[] split = viewParameters.split("&");
                String[] keyValue = split[0].split("=");
                if (keyValue.length > 1) {
                    if (keyValue[0].equals("i18n")) {
                        String[] split1 = keyValue[1].split(":");
                        return split1.length > 1 ? I18NUtility.getValue(split1[0], split1[1])
                            : I18NUtility.getValue(split1[0]);
                    }
                    return keyValue[1];
                } else {
                    return keyValue[0];
                }
            }
            return "";
        }
    }

package com.ags.lumosframework.web.vaadin.base;

import java.util.HashSet;
import java.util.Set;

import com.ags.lumosframework.web.common.functionality.ApplicationGroup;
import com.ags.lumosframework.web.common.functionality.ApplicationInfo;
import com.ags.lumosframework.web.common.functionality.ApplicationPageGroup;
import com.ags.lumosframework.web.common.functionality.ApplicationPageInfo;

/**
 * 用于扩展系统中菜单
 * <p>
 * 仍然可以利用@WebEntry向菜单中加入菜单分组信息等，该方式与其不冲突。
 * </tr>
 * 整个流程分为4个阶段，分别加载应用组，应用，菜单组，菜单等信息。方法的执行会按照顺序加载，即先加载所有实现类的ApplicationGroup，然后再加载所有实现类的Application。
 * </tr>
 * 所以该接口的扩展类可以仅仅选择实现这些接口里面的某些方法。
 * </tr>
 * 比如，如果需要向AdminUI里面加入定制化的某一个View,这个View不属于当前任何一个分组，那么实现者只需要实现loadApplicationPageGroup（） 和loadApplicationPageInfo（）即可
 *
 * @author yuri_li
 * @date 2019/08/01
 */
public interface IApplicationInfoLoader {

    /**
     * 向页面中心注册当前页面应用组的信息，该应用组表示应用所属应用的大类，如应用可以分为“运行期应用”，“编译期应用”，“管理相关应用”
     */
    void loadApplicationGroup();

    /**
     * 加载应用的信息，如工单，对象建模等模块，分属于ApplicationGroup
     */
    void loadApplication();

    /**
     * 加载应用信息里面的菜单分组信息，如建模里面的“工厂建模”，“人力资源”等菜单分页信息，分属于Application
     *
     */
    void loadApplicationPageGroup();

    /**
     * 加载具体的页面信息，分属于ApplicationPageGroup
     */
    void loadApplicationPageInfo();

    /**
     * 返回例外的ApplicationGroup,在菜单页里不会加载出来
     *
     * @return
     */
    default Set<ApplicationGroup> getExcludedApplicationGroups() {
        return new HashSet<>();
    };

    /**
     * 返回例外的ApplicationInfo,在菜单页里不会加载出来
     *
     * @return
     */
    default Set<ApplicationInfo> getExcludedApplicationInfos() {
        return new HashSet<>();
    };

    /**
     * 返回例外的ApplicationPageGroup,在菜单页里不会加载出来
     *
     * @return
     */
    default Set<ApplicationPageGroup> getExcludedApplicationPageGroups() {
        return new HashSet<>();
    };

    /**
     * 返回例外的ApplicationPageInfo,在菜单页里不会加载出来
     *
     * @return
     */
    default Set<ApplicationPageInfo> getExcludedApplicationPageInfos() {
        return new HashSet<>();
    };
}

@Component
public class ReportApplicationLoader implements IApplicationInfoLoader {

    @Override
    public void loadApplicationGroup() {

    }

    @Override
    public void loadApplication() {

    }

    @Override
    public void loadApplicationPageGroup() {
        ApplicationInfo appInfoByAppPath = ApplicationManager.getAppInfoByAppPath(CommonConstants.REPORT);
        // 生产看板
        ApplicationPageGroup build = ApplicationPageGroup.builder().applicationInfo(appInfoByAppPath)
            .name(MesConstants.MENU_GROUP_Production_KanBan_Default)
            .captionI18NKey(MesConstants.MENU_GROUP_Production_KanBan_I18N)
            .caption(MesConstants.MENU_GROUP_Production_KanBan_Default)
            .iconPath("images/icon/report/ProductionDashboard.png").order(0).build();
        ApplicationManager.addApplicationPageGroup(build);

        // 投入产出
        build = ApplicationPageGroup.builder().applicationInfo(appInfoByAppPath)
            .name(MesConstants.MENU_GROUP_OUTPUT_Default).captionI18NKey(MesConstants.MENU_GROUP_OUTPUT_I18N)
            .caption(MesConstants.MENU_GROUP_OUTPUT_Default).iconPath("images/icon/report/Input-outputReport.png")
            .order(1).build();
        ApplicationManager.addApplicationPageGroup(build);

        // 在制
        build =
            ApplicationPageGroup.builder().applicationInfo(appInfoByAppPath).name(MesConstants.MENU_GROUP_WIP_Default)
                .captionI18NKey(MesConstants.MENU_GROUP_WIP_I18N).caption(MesConstants.MENU_GROUP_WIP_Default)
                .iconPath("images/icon/report/In-processReport.png").order(2).build();
        ApplicationManager.addApplicationPageGroup(build);

        // 工单
        build = ApplicationPageGroup.builder().applicationInfo(appInfoByAppPath)
            .name(MesConstants.MENU_GROUP_WorkOrder_Default).captionI18NKey(MesConstants.MENU_GROUP_WorkOrder_I18N)
            .caption(MesConstants.MENU_GROUP_WorkOrder_Default).iconPath("images/icon/report/WorkOrderReport.png")
            .order(3).build();
        ApplicationManager.addApplicationPageGroup(build);

        // 质量
        build = ApplicationPageGroup.builder().applicationInfo(appInfoByAppPath)
            .name(MesConstants.MENU_GROUP_Quality_Default).captionI18NKey(MesConstants.MENU_GROUP_Quality_I18N)
            .caption(MesConstants.MENU_GROUP_Quality_Default).iconPath("images/icon/report/QualityReport.png").order(4)
            .build();
        ApplicationManager.addApplicationPageGroup(build);
    }

    @Override
    public void loadApplicationPageInfo() {

    }

    /**
     * 移除administration相关模块，
     * @return
     */
    @Override
    public Set<ApplicationInfo> getExcludedApplicationInfos() {
        Set<ApplicationInfo> applicationPageInfos = new HashSet<>();
        ApplicationInfo administration = ApplicationInfo.builder().path("administration").build();
        applicationPageInfos.add(administration);
        return applicationPageInfos;
    }

    /**
     * 移除administration模块下的OC组
     * @return
     */
    @Override
    public Set<ApplicationPageGroup> getExcludedApplicationPageGroups() {
        Set<ApplicationPageGroup> applicationPageGroups = new HashSet<>();
        ApplicationInfo administration = ApplicationManager.getAppInfoByAppPath("administration");
        ApplicationPageGroup build = ApplicationPageGroup.builder().name(LumosConstants.ADMIN_OC_RELATED_Default)
            .applicationInfo(administration).build();
        applicationPageGroups.add(build);
        return applicationPageGroups;
    }

    /**
     * 移除administration模块下的custexttable（自定义表）菜单
     * @return
     */
    @Override
    public Set<ApplicationPageInfo> getExcludedApplicationPageInfos() {
        Set<ApplicationPageInfo> applicationPageInfos = new HashSet<>();
        ApplicationInfo administration = ApplicationManager.getAppInfoByAppPath("administration");
        ApplicationPageInfo custexttable =
            ApplicationPageInfo.builder().applicationInfo(administration).name("custexttable").build();
        applicationPageInfos.add(custexttable);
        return applicationPageInfos;
    }
}

package com.ags.lumosframework.web.vaadin.ui.help;
import com.ags.lumosframework.web.common.functionality.IHelpItemInfo;
import org.springframework.stereotype.Component;
@Component
public class JavaApiDocLumos implements IHelpItemInfo {

    //返回Link控件的标题
    @Override
    public String getCaption() {
        String caption = "JavaApiDoc-lumos"
        return caption;
    }

    //返回Link控件的链接地址
    @Override
    public String getPath() {
        String path = "help/apidocs-lumos/index.html"
        return path;
    }

    //返回控件位置优先级，越小优先级越高
    @Override
    public int getShowOrder() {
        int order = 1
        return order;
    }
}

<plugin>
    <artifactId>lumos-chm-tool</artifactId>
    <version>3.0.0-SNAPSHOT</version>
    <groupId>com.ags.lumosframework</groupId>
    <dependencies>
        <dependency>
            <groupId>com.ags.mes</groupId>
            <artifactId>mes-core-api</artifactId>
            <version>4.0.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
    <executions>
        <execution>
            <id>generateHTML</id>
            <phase>package</phase>
            <goals>
                <goal>chm</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <packagePaths>
            <packagePath>
                com.ags.mes.server.api.entity
            </packagePath>
        </packagePaths>
    </configuration>
</plugin>

package com.ags.lumosframework.web.vaadin.component.paginationobjectlist;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import com.ags.lumosframework.sdk.base.pagination.PageInfo;
import com.ags.lumosframework.web.common.i18.I18NUtility;
import com.ags.lumosframework.web.vaadin.base.BaseView;
import com.github.appreciated.material.MaterialTheme;
import com.vaadin.data.ValueProvider;
import com.vaadin.data.provider.DataProvider;
import com.vaadin.data.provider.GridSortOrder;
import com.vaadin.data.provider.ListDataProvider;
import com.vaadin.data.provider.QuerySortOrder;
import com.vaadin.event.selection.SelectionEvent;
import com.vaadin.event.selection.SelectionListener;
import com.vaadin.icons.VaadinIcons;
import com.vaadin.shared.ui.MarginInfo;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Component;
import com.vaadin.ui.Grid;
import com.vaadin.ui.Grid.Column;
import com.vaadin.ui.Grid.SelectionMode;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
import com.vaadin.ui.VerticalLayout;
import com.vaadin.ui.components.grid.GridSelectionModel;
import com.vaadin.ui.components.grid.MultiSelectionModelImpl;
import com.vaadin.ui.components.grid.NoSelectionModel;
import com.vaadin.ui.components.grid.SingleSelectionModelImpl;
import com.vaadin.ui.renderers.AbstractRenderer;
import com.vaadin.ui.renderers.TextRenderer;
import com.vaadin.ui.themes.ValoTheme;

/**
 * 可以绑定任何对象，如果需要使用单表对象，建议参考{PaginationDomainObjedtList}
 *
 * @author yuri_li
 * @date 2019/08/08
 */
public class PaginationObjectListGrid<T> extends BaseView implements IObjectListGrid<T>, ClickListener {

    /**
     *
     */
    private static final long serialVersionUID = -3903777668282783935L;
    public static int LOADING_DATA_SIZE = 30;
    public Set<String> columnNameList = new HashSet<String>();
    protected Grid<T> grid = new Grid<>();
    List<GridSortOrder<T>> sortOrder = Collections.emptyList();
    private IObjectClickListener<T> objectClickListener = null;
    private IObjectSelectionListener<T> objectSelectionListener = null;
    private List<T> data = null;
    private boolean isLocalModel = false;
    @SuppressWarnings("unused")
    private boolean isDialog = false;

    private Label lblPageInfo = new Label();
    private Button btnCurrentPage = new Button();
    private Button btnFirstPage = new Button();
    private Button btnLastPage = new Button();
    private Button btnPreviousPage = new Button();
    private Button btnNextPage = new Button();
    private Button[] btns = {btnFirstPage, btnLastPage, btnCurrentPage, btnPreviousPage, btnNextPage};
    private int currentPage = 1;
    private int pageSize = LOADING_DATA_SIZE;
    private int totalCount = -1;
    private int startPosition = 0;

    protected IPagingQuery<T> pagingQuery = null;

    public PaginationObjectListGrid(IPagingQuery<T> queryFilter) {
        pagingQuery = queryFilter;
        initGrid();
        VerticalLayout vlRoot = new VerticalLayout();
        vlRoot.addStyleName(MaterialTheme.CARD_0 + " " + MaterialTheme.CARD_NO_PADDING);
        vlRoot.setSpacing(false);
        vlRoot.setSizeFull();
        vlRoot.addComponent(grid);
        vlRoot.setExpandRatio(grid, 1);
        vlRoot.setId("vl_root");
        setElementsId();

        HorizontalLayout hlTool = new HorizontalLayout();
        hlTool.setSpacing(false);
        hlTool.setMargin(new MarginInfo(true, false, false, false));
        hlTool.setDefaultComponentAlignment(Alignment.MIDDLE_RIGHT);
        hlTool.setWidth("100%");
        HorizontalLayout hlMsg = new HorizontalLayout();
        hlMsg.setWidth("100%");
        hlMsg.addComponent(lblPageInfo);
        hlTool.addComponents(hlMsg, btnFirstPage, btnPreviousPage, btnCurrentPage, btnNextPage, btnLastPage);
        hlTool.setExpandRatio(hlMsg, 1);

        btnCurrentPage.addStyleNames(MaterialTheme.BUTTON_FRIENDLY);
        btnCurrentPage.setEnabled(false);
        btnPreviousPage.setIcon(VaadinIcons.ANGLE_LEFT);
        btnNextPage.setIcon(VaadinIcons.ANGLE_RIGHT);
        btnFirstPage.setIcon(VaadinIcons.ANGLE_DOUBLE_LEFT);
        btnLastPage.setIcon(VaadinIcons.ANGLE_DOUBLE_RIGHT);
        for (Button btn : btns) {
            btn.setDisableOnClick(true);
            btn.addClickListener(this);
            btn.addStyleNames(MaterialTheme.BUTTON_ICON_ONLY, ValoTheme.BUTTON_SMALL);
        }

        vlRoot.addComponent(hlTool);
        vlRoot.setComponentAlignment(hlTool, Alignment.MIDDLE_RIGHT);
        this.setSizeFull();
        this.setCompositionRoot(vlRoot);
    }

    private void setElementsId() {
        lblPageInfo.setId("lbl_nowpage");
        btnCurrentPage.setId("btn_currentpage");
        btnFirstPage.setId("btn_firstpage");
        btnLastPage.setId("btn_lastpage");
        btnPreviousPage.setId("btn_previouspage");
        btnNextPage.setId("btn_nextpage");
    }

    private void initGrid() {
        grid.addStyleNames(MaterialTheme.GRID_BORDERLESS);
        grid.addColumn(new ValueProvider<T, String>() {
            private static final long serialVersionUID = 2776458444454640094L;

            @Override
            public String apply(T source) {
                return data.indexOf(source) + startPosition + 1 + "";
            }
        }).setCaption(I18NUtility.getValue("common.id", "ID")).setMinimumWidth(60);
        grid.addItemClickListener(event -> {
            if (objectClickListener != null) {
                objectClickListener.itemClicked(event);
            }
        });
        grid.addSelectionListener(new SelectionListener<T>() {
            private static final long serialVersionUID = 4404475737160537026L;

            @Override
            public void selectionChange(SelectionEvent<T> event) {
                if (objectSelectionListener != null) {
                    objectSelectionListener.itemClicked(event);
                }
            }
        });
        grid.addSortListener(listener -> {
            sortOrder = listener.getSortOrder();
            refresh();
        });
        grid.setSizeFull();
    }

    @Override
    public void setStartPage(int currentPage, int startPosition) {
        this.currentPage = currentPage;
        this.startPosition = startPosition;
    }

    @Override
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    @Override
    public Column<T, ?> addColumn(String propertyName) {
        return grid.addColumn(propertyName, new TextRenderer()).setSortOrderProvider(direction -> {
            List<QuerySortOrder> list = new ArrayList<>();
            list.add(new QuerySortOrder(propertyName, direction));
            return list.stream();
        }).setHidable(true);
    }

    @Override
    public Column<T, ?> addColumn(String propertyName, AbstractRenderer<? super T, ?> renderer) {
        return grid.addColumn(propertyName, renderer).setSortOrderProvider(direction -> {
            List<QuerySortOrder> list = new ArrayList<>();
            list.add(new QuerySortOrder(propertyName, direction));
            return list.stream();
        }).setHidable(true);
    }

    @Override
    public <V> Column<T, V> addColumn(ValueProvider<T, V> valueProvider) {
        return grid.addColumn(valueProvider, new TextRenderer()).setHidable(true);
    }

    @Override
    public <V> Column<T, V> addColumn(ValueProvider<T, V> valueProvider,
        AbstractRenderer<? super T, ? super V> renderer) {
        return grid.addColumn(valueProvider, renderer).setHidable(true);
    }

    @Override
    public <V> Column<T, V> addColumn(ValueProvider<T, V> valueProvider,
        ValueProvider<V, String> presentationProvider) {
        return grid.addColumn(valueProvider, presentationProvider).setHidable(true);
    }

    @Override
    public <V, P> Column<T, V> addColumn(ValueProvider<T, V> valueProvider, ValueProvider<V, P> presentationProvider,
        AbstractRenderer<? super T, ? super P> renderer) {
        return grid.addColumn(valueProvider, presentationProvider, renderer).setHidable(true);
    }

    @Override
    public <V extends Component> Column<T, V> addComponentColumn(ValueProvider<T, V> componentProvider) {
        return grid.addComponentColumn(componentProvider).setHidable(true);
    }

    @Override
    public void setData(List<T> data) {
        this.data = data;
        this.isLocalModel = true;
    }

    /*
     * (non-Javadoc)
     *
     * @see com.ags.jaspermes.ui.component.IDomainObjectGrid#refresh()
     */
    @Override
    public void refresh() {
        if (isLocalModel) {
            ListDataProvider<T> ofCollection = DataProvider.ofCollection(data);
            grid.setDataProvider(ofCollection);
            if (!data.isEmpty()) {
                grid.select(data.get(0));
            }
        } else {
            pagingQuery.init();
            totalCount = pagingQuery.count();

            data = pagingQuery.list(new PageInfo(currentPage, pageSize)).getRecords();
            ListDataProvider<T> ofCollection = DataProvider.ofCollection(data);
            grid.setDataProvider(ofCollection);
            updateButtonStatus();
            updatePageInfo();
        }
    }

    @Override
    public void refresh(T item) {
        grid.getDataProvider().refreshItem(item);
    }

    @Override
    public void setObjectClickListener(IObjectClickListener<T> listener) {
        this.objectClickListener = listener;
    }

    @Override
    public void setObjectSelectionListener(IObjectSelectionListener<T> listener) {
        this.objectSelectionListener = listener;
    }

    @Override
    public T getSelectedObject() {
        Iterator<T> iterator = grid.getSelectedItems().iterator();
        if (iterator.hasNext()) {
            return iterator.next();
        } else {
            return null;
        }
    }

    @Override
    public void addStyleNameToGrid(String style) {
        grid.addStyleName(style);
    }

    @Override
    public SelectionMode getSelectionMode() {
        GridSelectionModel<T> selectionModel = grid.getSelectionModel();
        SelectionMode mode = null;
        if (selectionModel.getClass().equals(SingleSelectionModelImpl.class)) {
            mode = SelectionMode.SINGLE;
        } else if (selectionModel.getClass().equals(MultiSelectionModelImpl.class)) {
            mode = SelectionMode.MULTI;
        } else if (selectionModel.getClass().equals(NoSelectionModel.class)) {
            mode = SelectionMode.NONE;
        }
        return mode;
    }

    @Override
    public void setSelectionMode(SelectionMode selectionMode) {
        grid.setSelectionMode(selectionMode);
    }

    @Override
    public List<T> getSelections() {
        List<T> selections = new ArrayList<T>();
        selections.addAll(grid.getSelectedItems());
        return selections;
    }

    @Override
    public void select(List<T> selected) {
        grid.deselectAll();
        selected.forEach(grid::select);
    }

    @Override
    public void setSort(String columnName) {
        columnNameList.add(columnName);
    }

    @Override
    public void clearSortColumnName() {
        columnNameList.clear();
    }

    @Override
    public void setIsDialog(boolean isDialog) {
        this.isDialog = isDialog;
    }

    @Override
    public void buttonClick(ClickEvent event) {
        Button button = event.getButton();
        button.setEnabled(true);
        if (button.equals(btnFirstPage)) {
            currentPage = 1;
            startPosition = 0;
        } else if (button.equals(btnLastPage)) {
            currentPage = totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;;
            startPosition = (currentPage - 1) * pageSize;
        } else if (button.equals(btnPreviousPage)) {
            if (currentPage - 1 != 0) {
                currentPage--;
            }
            startPosition = (currentPage - 1) * pageSize;
        } else if (button.equals(btnNextPage)) {
            if (currentPage * pageSize < totalCount) {
                currentPage++;
            }
            startPosition = (currentPage - 1) * pageSize;

        }
        updateButtonStatus();
        updatePageInfo();
        refresh();
        grid.scrollToStart();
    }

    private void updateButtonStatus() {
        if (startPosition + pageSize < totalCount) {
            btnNextPage.setEnabled(true);
            btnLastPage.setEnabled(true);
        } else {
            btnNextPage.setEnabled(false);
            btnLastPage.setEnabled(false);
        }

        if (currentPage == 1) {
            btnFirstPage.setEnabled(false);
            btnPreviousPage.setEnabled(false);
        } else {
            btnFirstPage.setEnabled(true);
            btnPreviousPage.setEnabled(true);
        }
    }

    private void updatePageInfo() {
        int i = totalCount % pageSize;
        int page = totalCount / pageSize;
        int pageCount = page + (i == 0 && page != 0 ? 0 : 1);
        btnCurrentPage.setCaption(String.valueOf(currentPage));
        if (columnNameList.size() > 2) {
            lblPageInfo.setValue(I18NUtility.getValue("common.page.totalcount", "Total Count") + ": "+ totalCount + " | "
                + I18NUtility.getValue("common.page.totalpage", "Total Page") + ": " + pageCount);
        } else {
            lblPageInfo.setValue(I18NUtility.getValue("common.page.totalpage", "Total Page") + ": " + pageCount);
        }
    }

    @Override
    public void setFilter(Object filter) {
        pagingQuery.setFilter(filter);
    }
}

private IDomainObjectGrid<WorkOrder> gridOrder = new PaginationDomainObjectList<>();

    /**
    * 页面添加小数点精确位数的设置
    */
    private void addDigitConfigurationPanel() {
        //创建ConfigurationItemPanel对象
        ConfigurationItemPanel digitCfgPanel = new ConfigurationItemPanel();
        digitCfgPanel.setId("pl_digit");
        //定义caption
        digitCfgPanel.setCaption(I18NUtility.getValue("Admin.System.Setting.DigitSetting", "Exact Digit Configuration"));
        //ConfigurationItemPanel中添加private TextConfigurationItem digit = new TextConfigurationItem(false)组件;
        digitCfgPanel.addConfigurationItem(digit);
        //系统配置页面添加ConfigurationItemPanel组件
        vlContent.addComponent(digitCfgPanel);

        digitCfgPanel.addItemSaveCallback(new ConfigurationItemSaveCallBack() {

            @Override
            public void done(ConfirmResult result) {
                if (ConfirmResult.Result.OK.equals(result.getResult())) {
                    @SuppressWarnings("unchecked")
                    Map<String, BaseConfigurationItem<?>> items =(Map<String, BaseConfigurationItem<?>>)result.getObj();
                    BaseConfigurationItem<?> configurationItem = items.get(digit.getCaption());
                    String digit = configurationItem.getValue().toString();
                    Configuration config = presenter.getDigitConfig();
                    config.setValue(digit);
                    presenter.saveDigitConfig();
                    loadConfigurations();
                }
            }
        });
    }

 //固定值
 CONSTANT("Constant", "Configuration.ExpressionType.Constant", ""),
 //数字
 NUMBER("Number", "Configuration.ExpressionType.Number", "[0-9]"),
 //字母
 CHARACTER("Character", "Configuration.ExpressionType.Character", "[a-zA-Z]"),
 //数字或字母
 NUMBER_AND_CHARACTER("NumberAndCharacter", "Configuration.ExpressionType.NumberAndCharacter", "[a-zA-Z0-9]"),
 //特殊字符
 SPECIAL_CHARACTER("SpecialCharacter", "Configuration.ExpressionType.SpecialCharacter", "[!@#$%^&*()_+=\\-\\s]");

package com.ags.lumosframework.web.vaadin.component.checkexpression;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

import com.ags.lumosframework.common.constant.CommonConstants;
import com.ags.lumosframework.common.enums.MatcherExpressionType;
import com.ags.lumosframework.web.common.i18.I18NUtility;
import com.google.common.base.Strings;

public class MatcherExpressionItem {

    private MatcherExpressionType itemType;
    private String itemValue;
    private int no;
    private MatcherExpressionTypeChangeListener typeChangeListener;

    public MatcherExpressionItem() {}

    public MatcherExpressionItem(int no) {
        this.no = no + 1;
    }

    public MatcherExpressionItem(int no, MatcherExpressionType type, String itemValue) {
        this.no = no;
        this.itemType = type;
        this.itemValue = itemValue;
    }

    public static List<MatcherExpressionItem> parseExpression(String persistenceExpression) {
        List<MatcherExpressionItem> items = new ArrayList<>();
        if (!Strings.isNullOrEmpty(persistenceExpression)) {
            String[] arrItems = persistenceExpression.split("\\" + CommonConstants.EXPRESSION_CONNECTOR);
            MatcherExpressionItem itemTemp = null;
            for (String arrItem : arrItems) {
                String valueOrLen = "";
                String typeTemp = arrItem;
                if (arrItem.indexOf('(') >= 0) {
                    arrItem = arrItem.replace(")", "");
                    String[] split = arrItem.split("\\(");
                    typeTemp = split[0];
                    valueOrLen = split[1];
                }
                MatcherExpressionType type = MatcherExpressionType.getValue(typeTemp);
                itemTemp = new MatcherExpressionItem(items.size());
                itemTemp.setItemType(type);
                itemTemp.setItemValue(valueOrLen);
                items.add(itemTemp);
            }
        }
        return items;
    }

    public static String getDisplay(List<MatcherExpressionItem> items) {
        StringBuilder res = new StringBuilder();
        items.sort((item1, item2) -> item1.getNo() - item2.getNo());
        for (MatcherExpressionItem item : items) {
            res.append(I18NUtility.getValue(item.getItemType().getNameKey(), item.getItemType().getName()));
            res.append("(" + item.getItemValue() + ")");
            res.append(CommonConstants.EXPRESSION_CONNECTOR);
        }
        String strRes = res.toString();
        if (strRes.endsWith(CommonConstants.EXPRESSION_CONNECTOR)) {
            strRes = strRes.substring(0, strRes.lastIndexOf(CommonConstants.EXPRESSION_CONNECTOR));
        }
        return strRes;
    }

    public static String toMatcherExpression(String persistenceExpression) {
        return toMatcherExpression(parseExpression(persistenceExpression));
    }

    public static String toMatcherExpression(List<MatcherExpressionItem> items) {
        StringBuilder res = new StringBuilder();
        for (int index = 0; index < items.size(); index++) {
            MatcherExpressionItem item = items.get(index);
            if (index == 0) {
                res.append('^');
            }
            if (MatcherExpressionType.CONSTANT.equals(item.getItemType())) {
                res.append(item.getItemValue());
            } else {
                res.append(item.getItemType().getMatcherExpression());
                res.append('{');
                res.append(item.getItemValue());
                res.append('}');
            }
            if (index == (items.size() - 1)) {
                res.append('$');
            }
        }
        return res.toString();
    }

    public static String toPersistenceExpression(List<MatcherExpressionItem> items) {
        StringBuilder res = new StringBuilder();
        items.sort((item1, item2) -> item1.getNo() - item2.getNo());
        for (MatcherExpressionItem item : items) {
            res.append(item.getItemType().getName());
            res.append("(" + item.getItemValue() + ")");
            res.append(CommonConstants.EXPRESSION_CONNECTOR);
        }
        String strRes = res.toString();
        if (strRes.endsWith(CommonConstants.EXPRESSION_CONNECTOR)) {
            strRes = strRes.substring(0, strRes.lastIndexOf(CommonConstants.EXPRESSION_CONNECTOR));
        }
        return strRes;
    }

    public MatcherExpressionType getItemType() {
        return itemType;
    }

    public void setItemType(MatcherExpressionType itemType) {
        this.itemType = itemType;
        if (Objects.nonNull(typeChangeListener)) {
            typeChangeListener.typeChange(itemType);
        }
    }

    public String getItemValue() {
        return itemValue;
    }

    public void setItemValue(String itemValue) {
        this.itemValue = itemValue;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public MatcherExpressionTypeChangeListener getTypeChangeListener() {
        return typeChangeListener;
    }

    public void setTypeChangeListener(MatcherExpressionTypeChangeListener typeChangeListener) {
        this.typeChangeListener = typeChangeListener;
    }

    public interface MatcherExpressionTypeChangeListener {
        void typeChange(MatcherExpressionType type);
    }

}

     @Inject
     private IObjectSelectDialog objectSelectDialog;

     else if (btnModifyActionGroup.equals(button)) {
         //设置后台服务的名称
         objectSelectDialog.setService(IFailureActionGroupService.class);
         objectSelectDialog.setSort(FailureActionCodeGroupEntity.NAME);
         objectSelectDialog.setIsDialog(true);
         //是否必选
         objectSelectDialog.setMustSelect(false);
         List<BuildtimeObjectBaseImpl<?>> fcs = new ArrayList<>();
         if (failureCode.getFailureActionCodeGroup() != null) {
             fcs.add(failureCode.getFailureActionCodeGroup());
         }
         //设置选择框的caption
         objectSelectDialog.setCaption(I18NUtility.getValue("Common.Select", "Select") + " "
             + I18NUtility.getValue("Configuration.Failure.FailureActionCodeGroup", "Failure Action Code Group"));
          //设置已经被绑定的数据页面展示是选中状态
         objectSelectDialog.select(fcs);
         objectSelectDialog.show(getUI(), new DialogCallBack() {
             @Override
             public void done(ConfirmResult result) {
                 if (result.getResult().equals(Result.OK)) {
                     FailureActionCodeGroup actionGroup = (FailureActionCodeGroup)result.getObj();
                     failureCode.setFailureActionCodeGroup(actionGroup);
                     presenter.saveFailureCode(failureCode);
                     lblFailureActionGroup.setValue(actionGroup == null ? "" : actionGroup.getActionCodeGroupName());
                 }
             }
         });
     }

package com.ags.lumosframework.web.vaadin.component.objectselect;

import java.util.List;

import com.ags.lumosframework.sdk.base.domain.ObjectBaseImpl;
import com.ags.lumosframework.sdk.base.filter.EntityFilter;
import com.ags.lumosframework.web.vaadin.base.IBaseDialog;
import com.vaadin.ui.Grid.SelectionMode;

public interface IObjectSelectDialog<T extends ObjectBaseImpl<?>> extends IBaseDialog {
    void setService(Class<?> serviceClass);

    void setCaption(String caption);

    void setSelectionMode(SelectionMode selectionMode);

    void select(List<T> selected);

    void selectOne(T selected);

    List<T> getSelections();

    void setData(List<T> datas);

    void setIsDialog(boolean isDialog);

    void setMustSelect(boolean mustSelect);

    void setSort(String columnName);

    void setEntityFilter(EntityFilter entityFilter);
}

    /**
     * 获取主项目和移动端配置的参数 生成二维码图片
     *
     * @return
     */
    @ApiOperation(value = "获取主项目和移动端配置", notes = "get config mobile")
    @RequestMapping(value = "/getConfigMoible", method = RequestMethod.GET)
    public RestResponse<String> getConfigMoible() {
        //查询已经配置好的主项目和移动端配置的参数
        Configuration mainProjectGatewayIp = configurationService.getByNameAndCategory(
            ConfigurationConstant.CFG_MAIN_PROJECT_GATEWAY_IP, ConfigurationConstant.CATEGORY_SYSTEM_MAIN_PROJECT);
        Configuration mainProjectGatewayPort = configurationService.getByNameAndCategory(
            ConfigurationConstant.CFG_MAIN_PROJECT_GATEWAY_PORT, ConfigurationConstant.CATEGORY_SYSTEM_MAIN_PROJECT);
        Configuration mainProjectName = configurationService.getByNameAndCategory(
            ConfigurationConstant.CFG_MAIN_PROJECT_NAME, ConfigurationConstant.CATEGORY_SYSTEM_MAIN_PROJECT);
        Configuration mobileProjectGatewayIp = configurationService.getByNameAndCategory(
            ConfigurationConstant.CFG_MOBILE_PROJECT_GATEWAY_IP, ConfigurationConstant.CATEGORY_SYSTEM_MOBILE);
        Configuration mobileProjectGatewayPort = configurationService.getByNameAndCategory(
            ConfigurationConstant.CFG_MOBILE_PROJECT_GATEWAY_PORT, ConfigurationConstant.CATEGORY_SYSTEM_MOBILE);
        Configuration mobileProjectName = configurationService.getByNameAndCategory(
            ConfigurationConstant.CFG_MOBILE_PROJECT_NAME, ConfigurationConstant.CATEGORY_SYSTEM_MOBILE);
        if(StringUtils.isEmpty(mainProjectGatewayIp.getValue())) {
            return new RestResponse<>(RestResponseCode.NOTFOUND, true, "success", "");
        }
        Map<String, String> valueMap = new HashMap<>();
        valueMap.put(ConfigurationConstant.SHOW_MAIN_PROJECT_GATEWAY_IP,
            mainProjectGatewayIp == null ? "" : mainProjectGatewayIp.getValue());
        valueMap.put(ConfigurationConstant.SHOW_MAIN_PROJECT_GATEWAY_PORT,
            mainProjectGatewayPort == null ? "" : mainProjectGatewayPort.getValue());
        valueMap.put(ConfigurationConstant.SHOW_MAIN_PROJECT_NAME,
            mainProjectName == null ? "" : mainProjectName.getValue());
        valueMap.put(ConfigurationConstant.SHOW_MOBILE_PROJECT_GATEWAY_IP,
            mobileProjectGatewayIp == null ? "" : mobileProjectGatewayIp.getValue());
        valueMap.put(ConfigurationConstant.SHOW_MOBILE_PROJECT_GATEWAY_PORT,
            mobileProjectGatewayPort == null ? "" : mobileProjectGatewayPort.getValue());
        valueMap.put(ConfigurationConstant.SHOW_MOBILE_PROJECT_NAME,
            mobileProjectName == null ? "" : mobileProjectName.getValue());
        // 转map换成json 调用生成二维码图片
        Object valuMapJson = JSONObject.toJSON(valueMap);
        byte[] byteArray = QRCodeUtils.generateQRCode(valuMapJson.toString());
        String byteString = Base64Utils.encodeToString(byteArray);
        return new RestResponse<>(RestResponseCode.OK, true, "success", byteString);
    }

package com.ags.lumosframework.common.util;

import java.io.ByteArrayOutputStream;
import java.util.Hashtable;
import java.util.Map;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.client.j2se.MatrixToImageConfig;
import com.google.zxing.client.j2se.MatrixToImageWriter;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;

import lombok.extern.slf4j.Slf4j;

/**
 * 转成二维码
 *
 * @author andrew_he
 *
 */
@Slf4j
public class QRCodeUtils {

    private static int onColor = 0xFF000000;     //前景色
    private static int offColor = 0xFFFFFFFF;    //背景色

    public static byte[] generateQRCode(String value) {
        byte[] byteArray = null;
        Map<EncodeHintType, Object> hints = new Hashtable<EncodeHintType, Object>();
        // 指定纠错等级
        hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.L);
        // 指定编码格式
        hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            BitMatrix bitMatrix = new MultiFormatWriter().encode(value, BarcodeFormat.QR_CODE, 500, 500, hints);
            MatrixToImageConfig config = new MatrixToImageConfig(onColor, offColor);
            MatrixToImageWriter.writeToStream(bitMatrix, "png", byteArrayOutputStream, config);
            byteArray = byteArrayOutputStream.toByteArray();
        } catch (Exception e) {
            log.error(e.getMessage());
        }
        return byteArray;
    }

    public static void generateQRCodeImage(String value) {

    }

}

Unresolved directive in core/uicomponents.adoc - include::/var/jenkins_home/workspace/lumos-doc/lumos-framework/lumos-common/src/main/java/com/ags/lumosframework/web/vaadin/component/barcode4j/QRCodeImage.java[]

    // 扩展属性按钮
    private Button btnCF = new Button();

    //扩展属性编辑组件
    @Inject
    private IEditCustomizedFieldDialog cfDialog;

    if (clickedButton.equals(btnCF)) {
        Part selectAccount = (Part)this.objectGrid.getSelectedObject();
        cfDialog.setObjectExtension(selectAccount);
        cfDialog.show(getUI(), null);
    }

    @Inject
    private ICommonPropertiesView commonProperties;

    //点击选中数据时，右侧显示公共属性
    protected void setDataToRight(BuildtimeObjectBaseImpl<?> object) {
        commonProperties.setFullSize();
        if (object != null) {
            if (object instanceof QtagRootCauseCategory) {
                commonProperties
                    .setCaptionName(I18NUtility.getValue("Configuration.RootCauseCategory", "Root Cause Category"));
            } else {
                commonProperties
                    .setCaptionName(I18NUtility.getValue("Configuration.RootCauseDetail", "Root Cause Detail"));
            }
        } else {
            commonProperties.setCaptionName("");
        }
        commonProperties.setObject(object);
    }

    private RoundImage image = null;

    image = new RoundImage();
    image.addDeleteClickListener(new ClickListener() {
        /**
         *
         */
        private static final long serialVersionUID = 1192024051414142281L;

        @Override
        public void buttonClick(ClickEvent event) {
            //点击时页面移除该组件
            hl.removeComponent(image);
            uploadEvent = null;
            image = null;
        }
    });

    //注入图片编辑组件
    @Inject
    private IPictureEdit pictureEdit;

    private ResponsiveRow addRow;
    //编辑按钮点击事件
   if (button.equals(btnEdit)) {
        Iterator<Component> iterator = addRow.iterator();
        List<Image> images = new ArrayList<>();
        while (iterator.hasNext()) {
            ResponsiveColumn next = (ResponsiveColumn)iterator.next();
            images.add((Image)next.getComponent());
        }
        pictureEdit.setPictures(images);
        pictureEdit.show(this.getUI(), new DialogCallBack() {

            @Override
            public void done(ConfirmResult result) {
                if (result.getResult().equals(ConfirmResult.Result.OK)) {
                    List<Image> newImages = (List<Image>)result.getObj();
                    presenter.editUnitStationImage(wip, newImages);
                    loadImages(wip);
                }
            }
        });
   }

    private void loadImages(WIP<?> wip) {
           addRow.removeAllComponents();
           if (wip == null) {
               return;
           }
            //获取需要展示的图片集合
           List<ObjectStationImage> unitStationImages = presenter.getWIPStationImages(wip);

           for (ObjectStationImage image : unitStationImages) {
               Image c = new Image(null, new StreamResource(new StreamSource() {
                   private static final long serialVersionUID = -6831297225306728042L;

                   @Override
                   public InputStream getStream() {
                       try {
                           return image.getMedia().getMediaStream();
                       } catch (Exception e) {
                           return null;
                       }

                   }
               }, ""));

               c.setData(image.getId());
               c.setSizeFull();
               try {
                   image.getMedia().getMediaStream();
                   addRow.addColumn().withDisplayRules(12, 12, 4, 4).withComponent(c);
               } catch (Exception e) {
                   NotificationUtils.notificationError(e.getMessage() + ":" + image.getMedia().getFileURL());
               }

           }
    }