前言

开发时注意遵循开发规范

一、明确需求

1.拿到问题

登录猪齿鱼敏捷管理，找到自己的问题，例如：

迁移 [GLD2030] 核算主体级成本中心定义

即功能编号：GLD2030，功能名称：核算主体级成本中心定义

2.拿到对应的 Screen页面、表

（1）拿到Screen页面

然后我们登录标准hec4.0演示环境，搜索功能编号

按回车进入相应的Screen页面

然后右键 -> 查看框架的源代码

注意地址栏，这样我们就拿到了Screen页面：gld/GLD2030/gld_responsibility_centers.screen

（2）拿到表

然后去标准hec4.0源码中查看此screen页面中源码，找到相应的bm

bm中的baseTable就指定了表：GLD_RESPONSIBILITY_CENTERS

3.开发涉及的文件

拿到 Screen页面和表之后，就可以开始开发了，开发涉及的文件将至少包括如下内容：

序号	类型	名称
1	多语言基表	`gld_responsibility_center_tl`
2	多语言表	`gld_responsibility_center`
3	DTO	`GldResponsibilityCenter`
4	Mapper	`GldResponsibilityCenterMapper`、`GldResponsibilityCenterMapper.xml`
5	Service	`IGldResponsibilityCenterService`、 `GldResponsibilityCenterServiceImpl`
6	Controller	`GldResponsibilityCenterController`
7	Screen页面	`gld_responsibility_center.screen`

为避免和原本的功能冲突，我们为我们的功能统一添加后缀 Test

功能名：[GLD2030] 核算主体级成本中心定义测试

序号	类型	名称
1	多语言基表	`gld_responsibility_center_test`
2	多语言表	`gld_responsibility_center_test_tl`
3	DTO	`GldResponsibilityCenterTest`
4	Mapper	`GldResponsibilityCenterTestMapper`、`GldResponsibilityCenterTestMapper.xml`
5	Service	`IGldResponsibilityCenterServiceTest`、 `GldResponsibilityCenterServiceTestImpl`
6	Controller	`GldResponsibilityCenterControllerTest`
7	Screen页面	`gld_responsibility_center_test.screen`

二、建表

严格遵循 01_功能迁移指引

1.修改Oracle表

登录标准hec4.0数据库，主要做以下两处变动：

将复数表名改为单数

将Oracle数据库中整型含义的Number都改为Number(38)

可以看到原表名为：

将其改为单数，然后将整型含义的Number都改为Number(38)

注意：主键和索引的复数也要记得改成单数

2.生成groovy

2.1 生成groovy

（1）访问 groovy 文件生成器地址：http://192.168.12.107:16060

（2）填写 author、fileName，检索表，回车，勾选表名，然后点击 生成Groovy

选项	格式	示例
author	email	[email protected]
fileName	YYYY-MM-DD-module	2019-06-26-GLD2030
表检索	表名（支持特殊字符%）	gld_responsibility_center

（3）将生成的 groovy 文件 放入到 hap-core-db 工程下

2.2 修改groovy

描述ID
- 将生成的groovy文件中多语言字段的comment中的id去掉
索引名

如：

3.导入mysql

将项目重新 clean install

先将hap-core-db模块clean install 一下，然后再将hap-db模块clean install一下（没有测过）

在parent下执行 process-resources 命令

mvn process-resources -D skipLiquibaseRun=false -D db.driver=com.mysql.jdbc.Driver -D db.url=jdbc:mysql://127.0.0.1:3306/hap_dev -D db.user=hap_dev -D db.password=hap_dev

三、生成后端代码

1.生成后端代码

启动 hssp 项目，访问代码生成器页面

http:// ${host}:$ {port}/${context}/generator/generator.html

2.后端调整

严格遵循 01_功能迁移指引

2.1 DTO

2.1.1 类

（1）每个DTO都对应数据库中的一张表，需要继承 BaseDTO，BaseDTO 中封装了 who字段以及扩展字段

（2）DTO类上需要加如下注解

@ExtensionAttribute(disable=true) ：扩展字段注解

@Table(name = “fnd_business_rule_b”) ：映射数据库表

@Getter、@Setter、@AllArgsConstructor、@NoArgsConstructor、 @Builder、@ToString： lombok注解

@MultiLanguage ：若有多语言字段，则需要加多语言注解，对应的多语言表为 baseTable_tl

2.1.2 字段

（1）静态属性字段

每一个字段都需要添加其对应的静态属性字段

（2）主键字段

主键字段需要加注解：

@Id ：主键注解

@GeneratedValue ：主键自增长注解。对于自增长、序列（SEQUENCE）类型的主键，需要添加注解@GeneratedValue

（3）多语言字段

多语言字段需要添加多语言字段注解

@MultiLanguageField ：多语言字段注解

（4）非数据库字段

非数据库字段需要添加@Transient
 javax.persistence.Transient

（5）字段类型

不使用基本类型，全部使用基本类型的包装类，如 Long 对应数据库中的INTEGER，而不是使用 long

数字类型主键统一采用 Long

金额、数量等精度严格浮点类型采用 BigDecimal。注意 BigDecimal 在计算、比较方面的特殊性

（6）条件查询字段

若需要对某些字段进行条件查询，则需要加 @Where 声明该字段可以被条件查询，并在Controller中配合 Criteria 使用

2.1.3 完整示例

package com.hand.hssp.gld.dto;

import com.hand.hap.core.annotation.MultiLanguage;
import com.hand.hap.core.annotation.MultiLanguageField;
import com.hand.hap.mybatis.annotation.ExtensionAttribute;
import com.hand.hap.mybatis.common.query.Where;
import com.hand.hap.system.dto.BaseDTO;
import lombok.*;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotEmpty;

import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Transient;
import java.util.Date;

/**
 * <p>
 * 核算主体级成本中心
 * </p>
 *
 * <p>
 * 一、类
 * 1. 每个DTO都对应数据库中的一张表，需要继承 BaseDTO
 *  BaseDTO 中封装了 who字段 以及 扩展字段
 *
 * 2.DTO类上需要加如下注解
 *      @ExtensionAttribute(disable=true)    ： 扩展字段注解
 *      @Table(name = "fnd_business_rule_b") ： 映射数据库表
 *      @Getter、@Setter、@AllArgsConstructor、@NoArgsConstructor、 @Builder、@ToString： lombok注解
 *      @MultiLanguage  ： 若有多语言字段，则需要加多语言注解，对应的多语言表为 baseTable_tl
 *
 * 二、静态属性字段
 *   每一个字段都需要添加其对应的静态属性字段
 *
 * 三、字段
 * 1.主键
 *    主键字段需要加注解：
 * 		@Id              ： 主键注解
 *
 *      @GeneratedValue  ： 主键自增长注解。
 *                          对于自增长、序列（SEQUENCE）类型的主键，需要添加注解@GeneratedValue
 * 2.多语言字段
 * 多语言字段需要添加多语言字段注解
 *        @MultiLanguageField   ： 多语言字段注解
 *
 * 3.非数据库字段
 * 非数据库字段需要添加@Transient
 *      javax.persistence.Transient
 *
 * 4.字段类型
 * >- 不使用基本类型，全部使用基本类型的`包装类`，如 Long 对应数据库中的INTEGER，而不是使用 long
 * >- 数字类型主键统一采用 Long
 * >- 金额、数量 等精度严格浮点类型采用 BigDecimal。注意 BigDecimal 在计算、比较方面的特殊性
 *
 * 5.条件查询字段
 * 若需要对某些字段进行条件查询，则需要加 @Where 声明该字段可以被条件查询，并在Controller中配合 Criteria 使用
 *
 *
 * </p>
 *
 * @author [email protected] 2019/01/08 13:50
 */

@ExtensionAttribute(disable = true)
@Table(name = "gld_responsibility_center")
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@ToString
@MultiLanguage
public class GldResponsibilityCenter extends BaseDTO {

    public static final String FIELD_RESPONSIBILITY_CENTER_ID = "responsibilityCenterId";
    public static final String FIELD_ACC_ENTITY_ID = "accEntityId";
    public static final String FIELD_RESPONSIBILITY_CENTER_CODE = "responsibilityCenterCode";
    public static final String FIELD_RESPONSIBILITY_CENTER_NAME = "responsibilityCenterName";
    public static final String FIELD_RESP_CENTER_TYPE_CODE = "respCenterTypeCode";
    public static final String FIELD_START_DATE_ACTIVE = "startDateActive";
    public static final String FIELD_END_DATE_ACTIVE = "endDateActive";
    public static final String FIELD_SUMMARY_FLAG = "summaryFlag";
    public static final String FIELD_PARENT_RESP_CENTER_ID = "parentRespCenterId";
	public static final String FIELD_SUMMARY_TYPE = "summaryType";


    @Id
    @GeneratedValue
    private Long responsibilityCenterId;


    /**
     * 核算主体ID
     */
    // @NotNull
	@Where
    private Long accEntityId;
    /**
     * 核算主体名称
     */
	@Transient
    private String accEntityCode;
    /**
     * 核算主体代码
     */
    @Transient
	private String accEntityName;


    @NotEmpty
    @Length(max = 30)
    @Where
    private String responsibilityCenterCode;

    /**
     * 责任中心名称
     */
    @Length(max = 500)
    @MultiLanguageField
    @Where
    private String responsibilityCenterName;

    /**
     * 责任中心类型
     */
    @Length(max = 30)
    private String respCenterTypeCode;

    /**
     * 有效日期从
     */
    private Date startDateActive;

    /**
     * 有效日期至
     */
    private Date endDateActive;

    /**
     * 汇总标志
     */
    @NotEmpty
    @Length(max = 1)
    private String summaryFlag;

    /**
     * 上级责任中心
     */
    @Where
    private Long parentRespCenterId;


    @Transient
    private String summaryType;

	public GldResponsibilityCenter(Long accEntityId, String responsibilityCenterCode, String responsibilityCenterName, String respCenterTypeCode, Date startDateActive, Date endDateActive, String summaryFlag, Long parentRespCenterId) {
		this.accEntityId = accEntityId;
		this.responsibilityCenterCode = responsibilityCenterCode;
		this.responsibilityCenterName = responsibilityCenterName;
		this.respCenterTypeCode = respCenterTypeCode;
		this.startDateActive = startDateActive;
		this.endDateActive = endDateActive;
		this.summaryFlag = summaryFlag;
		this.parentRespCenterId = parentRespCenterId;
	}
}

2.2 Mapper

（1）GldResponsibilityCenterMapper

继承了通用Mapper接口之后，就具备了一些单表的增删改查操作。

package com.hand.hssp.gld.mapper;

import com.hand.hap.mybatis.common.Mapper;
import com.hand.hssp.gld.dto.GldResponsibilityCenter;
import org.apache.ibatis.annotations.Param;

import java.util.List;
/**
 * <p>
 *  GldResponsibilityCenterMapper
 * </p>
 * 
 * <p>
 *     > - 继承了通用Mapper接口之后，就具备了一些单表的增删改查操作。
 *     > - 如需要自定义一些多表查询，则需要自己写Mapper方法，并自己加以实现
 * </p>
 *
 * @author shira 2019/06/26 17:17
 */
public interface GldResponsibilityCenterMapper extends Mapper<GldResponsibilityCenter> {


}

（2）GldResponsibilityCenterMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.hand.hssp.gld.mapper.GldResponsibilityCenterMapper">
    <!-- 将查询结果中的SQL字段与DTO实体类字段一一映射，这样值就映射到实体类对象上了-->
    <resultMap id="BaseResultMap" type="com.hand.hssp.gld.dto.GldResponsibilityCenter">
        <result column="RESPONSIBILITY_CENTER_ID" property="responsibilityCenterId" jdbcType="DECIMAL"/>
        <result column="ACC_ENTITY_ID" property="accEntityId" jdbcType="DECIMAL"/>
        <result column="RESPONSIBILITY_CENTER_CODE" property="responsibilityCenterCode" jdbcType="VARCHAR"/>
        <result column="RESPONSIBILITY_CENTER_NAME" property="responsibilityCenterName" jdbcType="VARCHAR"/>
        <result column="RESP_CENTER_TYPE_CODE" property="respCenterTypeCode" jdbcType="VARCHAR"/>
        <result column="START_DATE_ACTIVE" property="startDateActive" jdbcType="DATE"/>
        <result column="END_DATE_ACTIVE" property="endDateActive" jdbcType="DATE"/>
        <result column="SUMMARY_FLAG" property="summaryFlag" jdbcType="VARCHAR"/>
        <result column="PARENT_RESP_CENTER_ID" property="parentRespCenterId" jdbcType="DECIMAL"/>
        <result column="SUMMARY_TYPE" property="summaryType" jdbcType="VARCHAR"/>
    </resultMap>


</mapper>

2.3 Service

（1）IGldResponsibilityCenterService

service 接口需要继承IBaseServcie 和 ProxySelf 这两个接口：

IBaseServcie 提供了基本的增删改查接口。

ProxySelf 提供了自身代理功能

package com.hand.hssp.gld.service;

import com.hand.hap.core.ProxySelf;
import com.hand.hap.system.service.IBaseService;
import com.hand.hssp.gld.dto.GldResponsibilityCenter;
import java.util.Date;
/**
 * <p>
 *  service 接口 需要继承IBaseServcie 和 ProxySelf 这两个接口：
 *       - IBaseServcie 提供了基本的增删改查接口。 
 *       - ProxySelf 提供了自身代理功能
 * </p>
 * 
 * @author shira 2019/06/28 10:19
 */
public interface IGldResponsibilityCenterService
                extends IBaseService<GldResponsibilityCenter>, ProxySelf<IGldResponsibilityCenterService> {
   
}

（3）GldResponsibilityCenterServiceImpl

类上需要加两个注解：

@Service : 声明Bean

@Transactional(rollbackFor = Exception.class) : 开启Spring声明式事务，有异常时会回滚。

需要继承 BaseServiceImpl 接口，这样就具有了单表的增删改查操作。

package com.hand.hssp.gld.service.impl;

import com.hand.hap.system.service.impl.BaseServiceImpl;
import com.hand.hssp.gld.dto.GldResponsibilityCenter;
import com.hand.hssp.gld.mapper.GldResponsibilityCenterMapper;
import com.hand.hssp.gld.service.IGldResponsibilityCenterService;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;

@Service
@Transactional(rollbackFor = Exception.class)
public class GldResponsibilityCenterServiceImpl extends BaseServiceImpl<GldResponsibilityCenter>
                implements IGldResponsibilityCenterService {


}

2.4 Controller

类上需要加 @Controller

需要继承 BaseController ，这样就有了一些通用方法，请求参数验证、异常处理

GldResponsibilityCenterController

package com.hand.hssp.gld.controllers;

import com.hand.hap.core.IRequest;
import com.hand.hap.mybatis.common.Criteria;
import com.hand.hap.mybatis.common.query.Comparison;
import com.hand.hap.mybatis.common.query.WhereField;
import com.hand.hap.system.controllers.BaseController;
import com.hand.hap.system.dto.ResponseData;
import com.hand.hssp.gld.dto.GldAccountingEntity;
import com.hand.hssp.gld.dto.GldResponsibilityCenter;
import com.hand.hssp.gld.service.IGldAccountingEntityService;
import com.hand.hssp.gld.service.IGldResponsibilityCenterService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
 * <p>
 *核算主体级成本中心
 * </p>
 *
 * @author [email protected] 2019/01/08 13:50
 */
@Controller
public class GldResponsibilityCenterController extends BaseController{

    @Autowired
    private IGldResponsibilityCenterService service;

	@Autowired
	private IGldAccountingEntityService gldAccountingEntityService;

    @RequestMapping("/gld/responsibility-center/query")
    @ResponseBody
    public ResponseData query(GldResponsibilityCenter dto, @RequestParam(defaultValue = DEFAULT_PAGE) int page,
        @RequestParam(defaultValue = DEFAULT_PAGE_SIZE) int pageSize, HttpServletRequest request) {
        IRequest requestContext = createRequestContext(request);
		Criteria criteria = new Criteria(dto);
		if(dto.getResponsibilityCenterCode()!=null){
			criteria.where(new WhereField(GldResponsibilityCenter.FIELD_RESPONSIBILITY_CENTER_CODE, Comparison.LIKE));
		}
		if(dto.getResponsibilityCenterName()!=null){
			criteria.where(new WhereField(GldResponsibilityCenter.FIELD_RESPONSIBILITY_CENTER_NAME, Comparison.LIKE));
		}
		if(dto.getAccEntityId()!=null){
			criteria.where(new WhereField(GldResponsibilityCenter.FIELD_ACC_ENTITY_ID));
		}
        return new ResponseData(service.selectOptions(requestContext,dto,criteria));
    }

    @RequestMapping("/gld/responsibility-center/submit")
    @ResponseBody
    public ResponseData update(@RequestBody List<GldResponsibilityCenter> dto, BindingResult result, HttpServletRequest request){
        getValidator().validate(dto, result);
        if (result.hasErrors()) {
        ResponseData responseData = new ResponseData(false);
        responseData.setMessage(getErrorMessage(result, request));
        return responseData;
        }
        IRequest requestCtx = createRequestContext(request);
        return new ResponseData(service.batchUpdate(requestCtx, dto));
    }

    @RequestMapping("/gld/responsibility-center/remove")
    @ResponseBody
    public ResponseData delete(HttpServletRequest request,@RequestBody List<GldResponsibilityCenter> dto){
        service.batchDelete(dto);
        return new ResponseData();
    }

	@RequestMapping(value = "/gld/GLD2030/gld_responsibility_center.screen")
	public ModelAndView gldResponsibilityCenter(HttpServletRequest request) {
		IRequest requestContext = createRequestContext(request);
		GldAccountingEntity gldAccountingEntity =new GldAccountingEntity();


        GldAccountingEntity defaultAccEntity = gldAccountingEntityService.queryDefaultAccEntity(requestContext,requestContext.getCompanyId());
		List<GldAccountingEntity> gldAccountingEntityList = gldAccountingEntityService.queryAccEntityByCompany(requestContext,requestContext.getCompanyId());

		ModelAndView view = new ModelAndView("gld/GLD2030/gld_responsibility_center");
		view.addObject("gldAccountingEntityList", gldAccountingEntityList);
		view.addObject("defaultAccEntity", defaultAccEntity);
		return view;
	}
}

四、功能管理

系统管理 -> 功能管理

1.资源管理

通常，所有要用到的链接都要注册成资源

gld/responsibility-center/query

gld/responsibility-center/submit

gld/GLD2030/gld_responsibility_center.screen

参考下图，注册资源

2.功能维护

参考下图的功能维护，维护一条功能。

入口页面可以是一个Html资源或URL资源，点击功能时会进入此入口页面

功能下用到的资源都需要加入到功能资源中

3.功能分配

勾选刚刚添加的功能

五、Screen页面调整

1.Screen页面调整

Screen页面还是原来的Screen页面，不过还需要进行部分调整，Screen页面调整部分，参见 01_功能迁移指引

2.Screen页面示例1

核算主体级成本中心的主页面（gld_responsibility_center.screen）示例如下：

此页面主要涉及到如下知识点：

多语言

SysCode、下拉框

默认值

条件查询和模糊查询

可参见 01_功能迁移指引

完整的代码见：gld_responsibility_center.screen

2.1 多语言

（1）实体类

@MultiLanguage
public class GldResponsibilityCenter extends BaseDTO {
   
   /**
     * 责任中心名称
     */
    @Length(max = 500)
    @MultiLanguageField
    @Where
    private String responsibilityCenterName;

}

（2）DataSet

多语言字段对应的field需要添加 dto 以及 dtoId 属性。

 <a:field name="responsibilityCenterName" required="true" prompt="gld_responsibility_center.responsibility_center_name" dto="com.hand.hssp.gld.dto.GldResponsibilityCenter" dtoId="responsibilityCenterId"/>

（2）Grid

<a:grid id="GLD2030_responsibilityCentersGrid" bindTarget="GLD2030_responsibilityCentersResultDs" marginHeight="115" marginWidth="3" navBar="true">
            <a:columns>

                <a:column name="responsibilityCenterName" align="left" editor="GLD2030_responsibilityCenterNameTld" width="200"/>
               
            </a:columns>
            <a:editors>
                <a:tledit id="GLD2030_responsibilityCenterNameTld"/>
            </a:editors>

2.2 下拉框

（1）sysCode类型的下拉框的数据来源：

 <a:dataSet id="GLD2030_respCenterTypeCodeDs" autoQuery="true" fetchAll="true"  queryUrl="$[/request/@context_path]/common/auroraCode/GLD.RESP_CENTER_TYPE/"/>

（2）下拉框的DataSet

            <a:dataSet id="GLD2030_responsibilityCentersResultDs" autoQuery="true" fetchAll="true" baseUrl="/gld/responsibility-center" queryDataSet="GLD2030_responsibilityCentersQueryDs" queryUrl="$[/request/@context_path]/gld/responsibility-center/query">
                <a:fields>

                    <a:field name="respCenterTypeCode"/>
                    <!-- 下拉框：成本中心类型-->
                    <a:field name="respCenterTypeCodeDisplay" displayField="meaning" options="GLD2030_respCenterTypeCodeDs" prompt="gld_responsibility_center.resp_center_type_code_display" required="true" valueField="value" returnField="respCenterTypeCode" />
                   
                </a:fields>
            </a:dataSet>

（3）下拉框的Grid

  <a:grid id="GLD2030_responsibilityCentersGrid" bindTarget="GLD2030_responsibilityCentersResultDs" marginHeight="115" marginWidth="3" navBar="true">
            <a:columns>

                <a:column name="respCenterTypeCodeDisplay" align="center" editor="GLD2030_gridCb" width="80"/>
               
            </a:columns>
            <a:editors>
                <a:comboBox id="GLD2030_gridCb"/>
            </a:editors>
    </a:grid>

2.3 默认值

如下图，QueryForm中有一个默认的核算主体字段，页面一进来的时候，就会查询这个默认的核算主体下的成本中心（每一个用户都有一个默认的核算主体）

也就是说，我们应该在页面渲染前，就准备好这个默认值。我们的做法是，在进入此页面前，先进入一个Controller方法通过ModelAndView的方式准备好这个默认值，然后再页面上直接用就行了

实现如下：

（1）维护功能的入口页面

将核算主体级成本中心这个功能的入口页面设置:gld/GLD2030/gld_responsibility_center.screen

（2）编写Controller方法

这样当用户点击功能时，就会跳转到下图的Controller中

@Controller
public class GldResponsibilityCenterController extends BaseController{

	@RequestMapping(value = "/gld/GLD2030/gld_responsibility_center.screen")
	public ModelAndView gldResponsibilityCenter(HttpServletRequest request) {
		IRequest requestContext = createRequestContext(request);
		GldAccountingEntity gldAccountingEntity =new GldAccountingEntity();


        GldAccountingEntity defaultAccEntity = gldAccountingEntityService.queryDefaultAccEntity(requestContext,requestContext.getCompanyId());
		List<GldAccountingEntity> gldAccountingEntityList = gldAccountingEntityService.queryAccEntityByCompany(requestContext,requestContext.getCompanyId());

		ModelAndView view = new ModelAndView("gld/GLD2030/gld_responsibility_center");
		view.addObject("gldAccountingEntityList", gldAccountingEntityList);
		view.addObject("defaultAccEntity", defaultAccEntity);
		return view;
	}
}

（3）Screen页面取值

 <a:dataSet id="GLD2030_responsibilityCentersQueryDs" autoCreate="true">
     <a:fields>
        <a:field name="accEntityNameDisplay" defaultValue="$[/model/defaultAccEntity/records/record/@accEntityName]" displayField="accEntityName" options="GLD2030_accEntityDs" prompt="gld_accounting_entities.acc_entity_name_display" required="true" returnField="accEntityId" valueField="accEntityId"/>
        <a:field name="accEntityId" defaultValue="$[/model/defaultAccEntity/records/record/@accEntityId]"  />
	 </a:fields>
</a:dataSet>

2.4 条件查询和模糊查询

hap对查询参数进行了限制，所有的条件查询，均需用 @Where 和 Criteria 手动声明

条件查询：Comparison.EQUAL

模糊查询：Comparison.LIKE

其他匹配条件请参见 Comparison 枚举类

（1）实体类添加 @Where

public class GldResponsibilityCenter extends BaseDTO {

    @NotEmpty
    @Length(max = 30)
    @Where
    private String responsibilityCenterCode;

    /**
     * 责任中心名称
     */
    @Length(max = 500)
    @MultiLanguageField
    @Where
    private String responsibilityCenterName;
  
}

（2）查询时结合 Criteria和selectOptions 进行查询

@Controller
public class GldResponsibilityCenterController extends BaseController{

    @Autowired
    private IGldResponsibilityCenterService service;

	@Autowired
	private IGldAccountingEntityService gldAccountingEntityService;

    @RequestMapping("/gld/responsibility-center/query")
    @ResponseBody
    public ResponseData query(GldResponsibilityCenter dto, @RequestParam(defaultValue = DEFAULT_PAGE) int page,
        @RequestParam(defaultValue = DEFAULT_PAGE_SIZE) int pageSize, HttpServletRequest request) {
        IRequest requestContext = createRequestContext(request);
		Criteria criteria = new Criteria(dto);
		if(dto.getResponsibilityCenterCode()!=null){
			criteria.where(new WhereField(GldResponsibilityCenter.FIELD_RESPONSIBILITY_CENTER_CODE, Comparison.LIKE));
		}
		if(dto.getResponsibilityCenterName()!=null){
			criteria.where(new WhereField(GldResponsibilityCenter.FIELD_RESPONSIBILITY_CENTER_NAME, Comparison.LIKE));
		}
		if(dto.getAccEntityId()!=null){
			criteria.where(new WhereField(GldResponsibilityCenter.FIELD_ACC_ENTITY_ID));
		}
        return new ResponseData(service.selectOptions(requestContext,dto,criteria));
    }


}

3.Screen页面示例2

核算主体级成本中心—分配预算实体页面（gld_resp_center_ref_bc.screen）如下：

此页面主要涉及如下知识点：

lov实现

可参见 01_功能迁移指引

完整的代码见：gld_resp_center_ref_bc.screen

3.1 lov查询映射

（1）定义Lov

系统管理->Lov定义

在Lov定义中定义一个Lov

填写相关信息：

ValueField：值字段，一般填写Id

TextField：文本字段，一般填写主要数据字段

自定义SQL：指定此LOV的数据来源

显示字段：配置要显示的字段

（2）DataSet

LovCode：通过LovCode指定要使用的Lov

from: 通过mapping的form子节点来实现lov到dataSet的字段映射的值来源

to：通过mapping的to子节点来实现lov到dataSet的字段映射的目标字段

<a:dataSet id="GLD2030_respCenterRefBeDs" autoPageSize="true" autoQuery="true"   baseUrl="/gld/resp-center-ref-bc" pageSize="10" queryUrl="$[/request/@context_path]/gld/resp-center-ref-bc/query?respCenterId=$[/parameter/@respCenterId]" selectable="true">
            <a:fields>
                <a:field name="bgtEntityId"/>
                <a:field name="bgtEntityName" lovCode="LOV_BGT_ENTITY?accEntityId=$[/parameter/@accEntityId]" autoComplete="true" required="true" prompt="bgt_entity.description" title="bgt_entity.bgt_entity">
                    <a:mapping>
                        <a:map from="entityId" to="bgtEntityId"/>
                        <a:map from="description" to="bgtEntityName"/>
                    </a:mapping>
                </a:field>
            </a:fields>
</a:dataSet>

即将lov的description字段映射到DataSet的bgtEntityName字段

（3）Grid

<a:grid id="GLD2030_respCenterRefBeGrid" bindTarget="GLD2030_respCenterRefBeDs" marginHeight="200" navBar="true" width="1000">
    <a:columns>
        <a:column name="bgtEntityName" align="center" editor="GLD2030_accEntityRefLov" width="200"/>
    </a:columns>
    <a:editors>
        <a:lov id="GLD2030_accEntityRefLov"/>
    </a:editors>
</a:grid>

3.2 lov字段带出

由于lov字段来自其他表，默认的单表查询是无法查出这些字段的，这样就会导致lov描述字段为空，因此要实现lov字段的带出，可通过关联其他表进行多表查询实现，也可通过hap提供了@JoinTable、@JoinClumn注解实现

（1）DTO

实体类添加 JoinTable 、 JoinColumn 注解

@JoinTable: 指定关联那张表，同时指定关联条件

@JoinColumn:指定要关联查询的字段

public class GldRespCenterRefBc extends BaseDTO {

    public static final String FIELD_BGT_ENTITY_ID = "bgtEntityId";
    public static final String FIELD_BGT_ENTITY_NAME = "bgtEntityName";


    /**
     * 预算实体ID
     */
    @JoinTable(name = "bgtEntityJoin", joinMultiLanguageTable = true, target = BgtEntity.class,
            type = JoinType.LEFT, on = {@JoinOn(joinField = BgtEntity.FIELD_ENTITY_ID)})
    @NotNull
    private Long bgtEntityId;



    /**
     * 预算实体名称
     */
    @JoinColumn(joinName = "bgtEntityJoin", field = BgtEntity.FIELD_DESCRIPTION)
    @Transient
    @Length(max = 500)
    private String bgtEntityName;
}

（2）Controller

查询时结合 Criteria 和 selectOptions使用

@Controller
@RequestMapping(value = "/gld/resp-center-ref-bc")
public class GldRespCenterRefBcController extends BaseController{

	@RequestMapping("/query")
	@ResponseBody
	public ResponseData query(GldRespCenterRefBc dto, @RequestParam(defaultValue = DEFAULT_PAGE) int page,
			@RequestParam(defaultValue = DEFAULT_PAGE_SIZE) int pageSize, HttpServletRequest request) {
		IRequest requestContext = createRequestContext(request);
		Criteria criteria = new Criteria(dto);
		criteria.where(new WhereField(GldRespCenterRefBc.FIELD_BGT_ENTITY_NAME),
				new WhereField(GldRespCenterRefBc.FIELD_BGT_CENTER_NAME),
				new WhereField(GldRespCenterRefBc.FIELD_RESP_CENTER_ID));
		return new ResponseData(service.selectOptions(requestContext,dto,criteria));
	}

}

3.3 lov传参

Lov的传参方式有如下两种：

lovCode传参

js传参

（1）lovCode传参

直接在lovCode属性后拼接参数即可

<a:dataSet id="GLD2030_respCenterRefBeDs" autoPageSize="true" autoQuery="true"   baseUrl="/gld/resp-center-ref-bc" pageSize="10" queryUrl="$[/request/@context_path]/gld/resp-center-ref-bc/query?respCenterId=$[/parameter/@respCenterId]" selectable="true">
            <a:fields>

                <a:field name="bgtEntityId"/>
                <a:field name="bgtEntityName" lovCode="LOV_BGT_ENTITY?accEntityId=$[/parameter/@accEntityId]" autoComplete="true" required="true" prompt="bgt_entity.description" title="bgt_entity.bgt_entity">
                    <a:mapping>
                        <a:map from="entityId" to="bgtEntityId"/>
                        <a:map from="description" to="bgtEntityName"/>
                    </a:mapping>
                </a:field>

            </a:fields>

</a:dataSet>

若有多个参数，则通过实体符号连接如：

lovCode="LOV_BGT_ENTITY?accEntityId=$[/parameter/@accEntityId]&amp;accEntityName=$[/parameter/@accEntityName]"

（3）JS传参

可参考：bgt_budget_balance_query.screen

record.getMeta().getField('parameterValueCode').setLovPara('bgtOrgId', bgtOrgId);
record.getMeta().getField('parameterValueCode').setLovPara('companyId', companyId);
record.getMeta().getField('parameterValueCode').setLovPara('parameterCode', parameterCode);
record.getMeta().getField('parameterValueCode').setTitle(record.get('parameterName'));

2.4 lov定义自定义sql示例

SELECT
    be.entity_id,
    be.entity_code,
    betl.description  
FROM
    bgt_entity be
    join bgt_entity_tl  betl on be.ENTITY_ID =betl.ENTITY_ID 
    and betl.LANG =  #{request.locale,jdbcType=VARCHAR,javaType=java.lang.String}
    AND be.enabled_flag = 'Y'
    and EXISTS (
            SELECT
                1 
            FROM
                gld_acc_entity_ref_be a 
            WHERE
                a.bgt_entity_id = be.entity_id 
                AND a.acc_entity_id = #{accEntityId} 
                AND a.enabled_flag = 'Y' 
    ) 
    <if test="entityCode != null">
        AND be.entity_code LIKE CONCAT('%',#{entityCode},'%')
    </if>
    <if test="description != null">
        AND be.description LIKE CONCAT('%',#{description},'%')
    </if>

凉风GG

发布了18 篇原创文章 · 获赞 4 · 访问量 6124

私信关注

02_单表功能开发

文章目录

前言