package cn.ksource.web.facade.xtpz.sjzd;
|
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.LinkedList;
|
import java.util.List;
|
import java.util.Map;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import org.apache.commons.lang.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import cn.ksource.beans.CONFIG_DATA_DICTIONARY;
|
import cn.ksource.beans.CONFIG_DATA_DICTIONARY_CATEGORY;
|
import cn.ksource.beans.CONFIG_DATA_INTERFACE;
|
import cn.ksource.beans.CONFIG_DATA_MESSAGE;
|
import cn.ksource.beans.CONFIG_DATA_SUBSYSTEM;
|
import cn.ksource.beans.GG_USER;
|
import cn.ksource.core.config.ConfigConstants;
|
import cn.ksource.core.dao.BaseDao;
|
import cn.ksource.core.dao.SqlParameter;
|
import cn.ksource.core.page.PageInfo;
|
import cn.ksource.core.util.ConvertUtil;
|
import cn.ksource.core.util.EqualUtil;
|
import cn.ksource.core.util.JsonUtil;
|
import cn.ksource.core.util.StringUtil;
|
import cn.ksource.core.web.TreeNode;
|
import cn.ksource.core.web.WebUtil;
|
import cn.ksource.web.Constants;
|
import cn.ksource.web.service.AreaService;
|
import cn.ksource.web.service.DataDictionaryService;
|
|
@Service("sjzdFacade")
|
public class SjzdFacadeImpl implements SjzdFacade {
|
|
@Autowired
|
private BaseDao baseDao;
|
|
@Autowired
|
private AreaService areaService;
|
|
@Autowired
|
private DataDictionaryService dataDictionaryService;
|
|
@Override
|
public List<Map> getSubSystemList() {
|
String sql = "select * from CONFIG_DATA_SUBSYSTEM";
|
return baseDao.queryForList(sql);
|
}
|
|
@Override
|
public Map getSubSystemInfo(String id) {
|
if (StringUtils.isBlank(id)) {
|
return new HashMap();
|
}
|
return baseDao.queryForMap("select * from CONFIG_DATA_SUBSYSTEM where id=:id",new SqlParameter("id",id));
|
}
|
|
@Override
|
public boolean addOrUpdateSubSystem(CONFIG_DATA_SUBSYSTEM subsystem) {
|
if (isSubSystemExists(subsystem.getSystemkey(), subsystem.getId())) {
|
return false;
|
}
|
subsystem.setSystemname(ConfigConstants.getSub_System_Label(subsystem.getSystemkey()));
|
if (StringUtils.isBlank(subsystem.getId())) {
|
subsystem.insert();
|
} else {
|
subsystem.update();
|
}
|
|
dataDictionaryService.updateSubSystemUrl(subsystem.getSystemkey());
|
return true;
|
}
|
|
private boolean isSubSystemExists(String key,String id) {
|
String sql = "select count(*) from CONFIG_DATA_SUBSYSTEM where SYSTEMKEY=:SYSTEMKEY";
|
if (StringUtils.isNotBlank(id)) {
|
sql += " and id != :id";
|
}
|
int count = baseDao.queryForInteger(sql,new SqlParameter("SYSTEMKEY",key).addValue("id", id));
|
if (count >0) {
|
return true;
|
}
|
return false;
|
}
|
|
@Override
|
public boolean delSubSystem(String id) {
|
CONFIG_DATA_SUBSYSTEM system = new CONFIG_DATA_SUBSYSTEM(id).getInstanceById();
|
dataDictionaryService.updateSubSystemUrl(system.getSystemkey());
|
system.deleteById();
|
return true;
|
}
|
|
private Object getType(Object type){
|
Map map = new HashMap();
|
map.put("1", "查询类");
|
map.put("2", "修改类");
|
map.put("3", "查询修改类");
|
return map.get(ConvertUtil.obj2Str(type));
|
}
|
|
@Override
|
public List<Map> getJiekouList(Map<String, String> paramMap) {
|
String sql = "select CONFIG_DATA_INTERFACE.*,CONFIG_DATA_SUBSYSTEM.SYSTEMNAME,CONFIG_DATA_SUBSYSTEM.URL " +
|
"from CONFIG_DATA_INTERFACE,CONFIG_DATA_SUBSYSTEM where " +
|
"CONFIG_DATA_INTERFACE.SYSTEMID=CONFIG_DATA_SUBSYSTEM.ID ";
|
|
String system_id = paramMap.get("system_id");
|
String interfacename = paramMap.get("interfacename");
|
String interfacekey = paramMap.get("interfacekey");
|
String interfaceurl = paramMap.get("interfaceurl");
|
|
if (StringUtils.isNotBlank(paramMap.get("system_id"))) {
|
sql += "and SYSTEMID=:SYSTEMID";
|
}
|
|
if (StringUtils.isNotBlank(interfacename)) {
|
sql += " and interfacename like '%"+ interfacename.replaceAll("\\s", "%") +"%'";
|
}
|
if (StringUtils.isNotBlank(interfacekey)) {
|
sql += " and interfacekey like '%"+ interfacekey.replaceAll("\\s", "%") +"%'";
|
}
|
if (StringUtils.isNotBlank(interfaceurl)) {
|
sql += " and interfaceurl like '%"+ interfaceurl.replaceAll("\\s", "%") +"%'";
|
}
|
|
List<Map> list = baseDao.queryForList(sql,new SqlParameter("SYSTEMID",system_id));
|
|
for (Map map : list) {
|
map.put("MYTYPE", getType(map.get("TYPE")));
|
}
|
|
return list;
|
}
|
|
public List<Map> getMessageList(Map<String, String> paramMap){
|
String sql = "select * from CONFIG_DATA_MESSAGE where 1=1 ";
|
|
String message_name = paramMap.get("message_name");
|
String interfacekey = paramMap.get("interfacekey");
|
String message_key = paramMap.get("message_key");
|
|
if (StringUtils.isNotBlank(message_name)) {
|
sql += " and message_name like '%"+ message_name.replaceAll("\\s", "%") +"%'";
|
}
|
if (StringUtils.isNotBlank(interfacekey)) {
|
sql += " and interfacekey like '%"+ interfacekey.replaceAll("\\s", "%") +"%'";
|
}
|
if (StringUtils.isNotBlank(message_key)) {
|
sql += " and message_key like '%"+ message_key.replaceAll("\\s", "%") +"%'";
|
}
|
List<Map> list = baseDao.queryForList(sql,new SqlParameter());
|
|
return list;
|
}
|
|
@Override
|
public Map getJiekouInfo(String id) {
|
String sql = "select * from CONFIG_DATA_INTERFACE where id=:id";
|
return baseDao.queryForMap(sql,new SqlParameter("id",id));
|
}
|
|
public Map getMessageInfo(String id){
|
String sql = "select * from CONFIG_DATA_MESSAGE where id=:id";
|
return baseDao.queryForMap(sql,new SqlParameter("id",id));
|
}
|
|
public Map getSjzdflInfo(String id){
|
String sql = "select * from CONFIG_DATA_DICTIONARY_CATEGORY where id=:id";
|
return baseDao.queryForMap(sql,new SqlParameter("id",id));
|
}
|
|
public Map getDataInfo(String id){
|
String sql = "select * from CONFIG_DATA_DICTIONARY where id=:id";
|
return baseDao.queryForMap(sql,new SqlParameter("id",id));
|
}
|
|
@Override
|
public Map getSubSystemMapUsing() {
|
String sql = "select * from CONFIG_DATA_SUBSYSTEM";
|
List<Map> list = baseDao.queryForList(sql);
|
Map result = new HashMap();
|
for (Map map : list) {
|
result.put(map.get("ID"), ConfigConstants.getSub_System_Label(map.get("SYSTEMKEY").toString()));
|
}
|
return result;
|
}
|
|
@Override
|
public boolean isJiekouExists(String id,String key) {
|
String sql = "select count(*) from CONFIG_DATA_INTERFACE where INTERFACEKEY=:INTERFACEKEY";
|
if (StringUtils.isNotBlank(id)) {
|
sql +=" and id != :id";
|
}
|
int count = baseDao.queryForInteger(sql,new SqlParameter("INTERFACEKEY",key).addValue("id", id));
|
if (count > 0) {
|
return true;
|
}
|
return false;
|
}
|
public boolean isMessageExists(String id,String key){
|
String sql = "select count(*) from CONFIG_DATA_MESSAGE where MESSAGE_KEY=:MESSAGE_KEY";
|
if (StringUtils.isNotBlank(id)) {
|
sql +=" and id != :id";
|
}
|
int count = baseDao.queryForInteger(sql,new SqlParameter("MESSAGE_KEY",key).addValue("id", id));
|
if (count > 0) {
|
return true;
|
}
|
return false;
|
}
|
|
public boolean isSjzdflExists(String id,String key){
|
String sql = "select count(*) from CONFIG_DATA_DICTIONARY_CATEGORY where CATEGORYKEY=:CATEGORYKEY AND USESTATE = 1 ";
|
if (StringUtils.isNotBlank(id)) {
|
sql +=" and id != :id";
|
}
|
int count = baseDao.queryForInteger(sql,new SqlParameter("CATEGORYKEY",key).addValue("id", id));
|
if (count > 0) {
|
return true;
|
}
|
return false;
|
}
|
|
public boolean isDataExists(String id,String key){
|
String sql = "select count(*) from CONFIG_DATA_DICTIONARY where DATAKEY=:DATAKEY";
|
if (StringUtils.isNotBlank(id)) {
|
sql +=" and id != :id";
|
}
|
int count = baseDao.queryForInteger(sql,new SqlParameter("DATAKEY",key).addValue("id", id));
|
if (count > 0) {
|
return true;
|
}
|
return false;
|
}
|
|
@Override
|
public boolean addOrUpdateJiekou(CONFIG_DATA_INTERFACE jiekou) {
|
|
if (isJiekouExists(jiekou.getId(), jiekou.getInterfacekey())) {
|
return false;
|
}
|
jiekou.insertOrUpdate();
|
|
dataDictionaryService.updateInterfaceUrlByKey(jiekou.getInterfacekey());
|
|
return true;
|
}
|
|
public boolean addOrUpdateMessage(CONFIG_DATA_MESSAGE message){
|
if (isMessageExists(message.getId(), message.getMessage_key())) {
|
return false;
|
}
|
message.insertOrUpdate();
|
|
dataDictionaryService.updateInterfaceUrlByMessageKey(message.getMessage_key());
|
|
return true;
|
}
|
|
public boolean addOrUpdateSjzdfl(CONFIG_DATA_DICTIONARY_CATEGORY category){
|
if (isSjzdflExists(category.getId(), category.getCategorykey())) {
|
return false;
|
}
|
if (EqualUtil.isStringEqual(category.getParentid(), "0")||StringUtil.isEmpty(category.getParentid())) {
|
category.setParentid(null);
|
}
|
category.setUsestate(1);
|
category.insertOrUpdate();
|
|
dataDictionaryService.updateDataDictionaryByCategoryKey(category.getCategorykey());
|
|
return true;
|
}
|
|
public boolean addOrUpdateData(CONFIG_DATA_DICTIONARY dic){
|
if (isDataExists(dic.getId(), dic.getDatakey())) {
|
return false;
|
}
|
dic.setUsestate(1);
|
dic.insertOrUpdate();
|
dataDictionaryService.updateDataDictionaryByKey(dic.getDatakey());
|
return true;
|
}
|
|
@Override
|
public boolean delJiekou(String id) {
|
CONFIG_DATA_INTERFACE inteConfig_data_interface = new CONFIG_DATA_INTERFACE(id).getInstanceById();
|
dataDictionaryService.updateInterfaceUrlByKey(inteConfig_data_interface.getInterfacekey());
|
inteConfig_data_interface.deleteById();
|
return true;
|
}
|
|
public boolean delMessage(String id){
|
CONFIG_DATA_MESSAGE message = new CONFIG_DATA_MESSAGE(id).getInstanceById();
|
dataDictionaryService.updateInterfaceUrlByMessageKey(message.getMessage_key());
|
message.deleteById();
|
return true;
|
}
|
|
@Override
|
public boolean deleteSjzdfl(String id){
|
CONFIG_DATA_DICTIONARY_CATEGORY cate = new CONFIG_DATA_DICTIONARY_CATEGORY(id).getInstanceById();
|
dataDictionaryService.updateDataDictionaryByCategoryKey(cate.getCategorykey());
|
cate.setUsestate(2).update();
|
return true;
|
}
|
public boolean delData(String id){
|
CONFIG_DATA_DICTIONARY data = new CONFIG_DATA_DICTIONARY(id).getInstanceById();
|
dataDictionaryService.updateDataDictionaryByKey(data.getDatakey());
|
data.setUsestate(2).update();
|
return true;
|
}
|
|
public TreeNode getSjzdflTree(String parentid){
|
|
TreeNode root = new TreeNode("0","数据字典");
|
String sql = "select * from CONFIG_DATA_DICTIONARY_CATEGORY where USESTATE=1";
|
|
if (StringUtils.isBlank(parentid) || StringUtils.equalsIgnoreCase(parentid, "0")) {
|
sql += " and parentid is null";
|
} else {
|
sql += " and parentid=:parentid";
|
}
|
sql += " order by ORDERNUM asc";
|
|
List<Map> xtgnList = baseDao.queryForList(sql, new SqlParameter("parentid",parentid));
|
Map<String, TreeNode> yjgnCache = new HashMap<String, TreeNode>();
|
|
for (Map map : xtgnList) {
|
TreeNode yjTree = new TreeNode(map.get("ID").toString(),
|
map.get("CATEGORYNAME")+"["+map.get("CATEGORYKEY")+"]");
|
yjTree.setIsOpen(true);
|
root.addChild(yjTree);
|
yjgnCache.put(ConvertUtil.obj2Str(map.get("ID")), yjTree);
|
}
|
return root;
|
}
|
|
public TreeNode getDataTree(String parentid){
|
TreeNode root = new TreeNode("0","数据字典");
|
String sql = "select * from CONFIG_DATA_DICTIONARY_CATEGORY where USESTATE=1";
|
|
boolean isOpen = false;
|
|
if (StringUtils.isBlank(parentid) || StringUtils.equalsIgnoreCase(parentid, "0")) {
|
sql += " and parentid is null";
|
} else {
|
sql += " and parentid=:parentid";
|
isOpen = true;
|
}
|
sql += " order by ORDERNUM asc";
|
|
List<Map> xtgnList = baseDao.queryForList(sql, new SqlParameter("parentid",parentid));
|
|
for (Map map : xtgnList) {
|
TreeNode yjTree = new TreeNode(map.get("ID").toString(),
|
map.get("CATEGORYNAME")+"["+map.get("CATEGORYKEY")+"]");
|
yjTree.setIsOpen(isOpen);
|
if (isOpen) {
|
Map attr = new HashMap();
|
attr.put("ISNODE", "1");
|
yjTree.setAttributes(attr);
|
}
|
root.addChild(yjTree);
|
}
|
return root;
|
}
|
|
@Override
|
public List<Map> getSjzdflList(String flid) {
|
String sql = "select * from CONFIG_DATA_DICTIONARY_CATEGORY where USESTATE=1";
|
if (StringUtils.isBlank(flid) || EqualUtil.isStringEqual(flid, "0")) {
|
sql += " and PARENTID is null ";
|
} else {
|
sql += " and PARENTID=:PARENTID ";
|
}
|
sql += " order by ORDERNUM";
|
List<Map> list = baseDao.queryForList(sql,new SqlParameter("PARENTID",flid));
|
return list;
|
}
|
|
public List<Map> getDataList(String flid){
|
String sql = "select * from CONFIG_DATA_DICTIONARY where USESTATE=1";
|
if (StringUtils.isBlank(flid) || EqualUtil.isStringEqual(flid, "0")) {
|
sql += " and CATEGORYID is null ";
|
} else {
|
sql += " and CATEGORYID=:CATEGORYID ";
|
}
|
sql += " order by ORDERNUM";
|
List<Map> list = baseDao.queryForList(sql,new SqlParameter("CATEGORYID",flid));
|
return list;
|
}
|
|
|
public String getAreaTree(String pid){
|
TreeNode node = areaService.getAreaTreeNode(pid);
|
if (StringUtils.isBlank(pid)) {
|
System.out.println(node.toJson());
|
return node.toJson();
|
} else {
|
System.out.println(node.getChildrenNodesForJson());
|
return node.getChildrenNodesForJson();
|
}
|
}
|
public void onArea_manager_configSubmit(HttpServletRequest request){
|
String ids = request.getParameter("areaids");
|
String type = request.getParameter("type");
|
String area_manager_id = request.getParameter("area_manager_id");
|
String area_manager_id_TEXT = request.getParameter("area_manager_id_TEXT");
|
if (StringUtils.isNotBlank(ids)) {
|
String delSql = "delete from CRM_SALES_AREA where COUNTY_ID in ('" + ids.replaceAll(",", "','") +"')";
|
baseDao.execute(delSql, new SqlParameter());
|
ids = StringUtils.removeEnd(ids, ",");
|
List<SqlParameter> paramList = new ArrayList<SqlParameter>();
|
String[] idsArray = ids.split(",");
|
String insertSql = "insert into CRM_SALES_AREA (ID,COUNTY_ID,TYPE,AREA_MANAGER_ID,AREA_MANAGER_NAME) " +
|
" VALUES(:ID,:COUNTY_ID,:TYPE,:AREA_MANAGER_ID,:AREA_MANAGER_NAME)";
|
for (String id : idsArray) {
|
paramList.add(new SqlParameter("ID",StringUtil.getUUID())
|
.addValue("COUNTY_ID", id)
|
.addValue("TYPE", type).addValue("AREA_MANAGER_ID", area_manager_id).addValue("AREA_MANAGER_NAME", area_manager_id_TEXT)
|
);
|
}
|
baseDao.executeBatch(insertSql, paramList);
|
}
|
}
|
|
@Override
|
public List<Map> getSjzdflList(HttpServletRequest request) {
|
String sql = "SELECT * FROM CONFIG_DATA_DICTIONARY_CATEGORY WHERE PARENTID IS NULL AND USESTATE=1 ORDER BY ORDERNUM";
|
List<Map> bms = baseDao.queryForList(sql);
|
return bms;
|
}
|
|
@Override
|
public List<Map> sjzdflData(HttpServletRequest request) {
|
Map paramMap = new HashMap();
|
String pId = request.getParameter("pId");
|
StringBuilder builder = new StringBuilder(" SELECT * FROM CONFIG_DATA_DICTIONARY_CATEGORY WHERE USESTATE=1 ");
|
if(StringUtil.notEmpty(pId)) {
|
builder.append(" AND PARENTID = :pId ");
|
paramMap.put("pId", pId);
|
} else {
|
builder.append(" AND PARENTID IS NULL ");
|
}
|
|
builder.append(" ORDER BY ORDERNUM");
|
|
List<Map> bms = baseDao.queryForList(builder.toString(),paramMap);
|
return bms;
|
}
|
|
/**
|
* 查询数据字典树形结构
|
*/
|
@Override
|
public List querySjzdTree(HttpServletRequest request) {
|
|
Map paramMap = new HashMap();
|
|
StringBuilder builder = new StringBuilder("SELECT * FROM CONFIG_DATA_DICTIONARY_CATEGORY WHERE USESTATE=1 ORDER BY PARENTID,ORDERNUM ASC");
|
|
List<Map> trees = baseDao.queryForList(builder.toString(),paramMap);
|
|
|
List<Map> resultList = new LinkedList<Map>();
|
|
Map<String, Map> yjgnCache = new HashMap<String, Map>();
|
|
for (Map map : trees) {
|
|
String treeId = ConvertUtil.obj2StrBlank(map.get("ID"));
|
String parentId = ConvertUtil.obj2StrBlank(map.get("PARENTID"));
|
|
//一级树
|
if (!StringUtil.notEmpty(parentId)) {
|
yjgnCache.put(treeId, map);
|
List<Map> ejgnList = new LinkedList<Map>();
|
map.put("ejTree", ejgnList);
|
resultList.add(map);
|
continue;
|
}
|
//二级树
|
String pId = map.get("PARENTID").toString();
|
if(yjgnCache.containsKey(pId)) {
|
Map yjgnMap = yjgnCache.get(pId);
|
List<Map> list = (List<Map>)yjgnMap.get("ejTree");
|
map.put("sjTree", new LinkedList<Map>());
|
list.add(map);
|
}
|
}
|
|
System.out.println(JsonUtil.list2Json(resultList));
|
return resultList;
|
}
|
|
@Override
|
public PageInfo querySjzdData(PageInfo pageInfo,String categoryId) {
|
StringBuilder sql = new StringBuilder();
|
sql.append("SELECT D.* FROM CONFIG_DATA_DICTIONARY D ");
|
SqlParameter param = new SqlParameter();
|
|
sql.append(" INNER JOIN CONFIG_DATA_DICTIONARY_CATEGORY C");
|
sql.append(" ON D.CATEGORYID=C.ID WHERE 1=1 ");
|
|
|
if(StringUtil.notEmpty(categoryId)) {
|
sql.append(" AND D.CATEGORYID=:categoryid ");
|
param.addValue("categoryid",categoryId);
|
} else {
|
sql.append(" AND D.CATEGORYID IS NULL ");
|
}
|
|
sql.append(" ORDER BY D.ORDERNUM");
|
return baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), param);
|
}
|
|
@Override
|
public int querySjzdCount(String categoryId) {
|
StringBuilder sql = new StringBuilder();
|
sql.append("SELECT COUNT(D.ID) FROM CONFIG_DATA_DICTIONARY D ");
|
SqlParameter param = new SqlParameter();
|
|
sql.append(" INNER JOIN CONFIG_DATA_DICTIONARY_CATEGORY C");
|
sql.append(" ON D.CATEGORYID=C.ID WHERE 1=1 ");
|
|
|
if(StringUtil.notEmpty(categoryId)) {
|
sql.append(" AND D.CATEGORYID=:categoryid ");
|
param.addValue("categoryid",categoryId);
|
} else {
|
sql.append(" AND D.CATEGORYID IS NULL ");
|
}
|
|
return baseDao.queryForInteger(sql.toString(), param);
|
}
|
|
|
@Override
|
public String sjzdExists(HttpServletRequest request) {
|
StringBuilder builder = new StringBuilder("SELECT COUNT(ID) FROM CONFIG_DATA_DICTIONARY WHERE CATEGORYID = :cateId AND DATAKEY = :datakey ");
|
String datakey = request.getParameter("val");
|
String cateId = request.getParameter("cateId");
|
Map paramMap = new HashMap();
|
paramMap.put("datakey", datakey);
|
paramMap.put("cateId", cateId);
|
String id = request.getParameter("id");
|
if(StringUtil.notEmpty(id)) {
|
builder.append(" AND ID != :id ");
|
paramMap.put("id", id);
|
}
|
|
int count = baseDao.queryForInteger(builder.toString(),paramMap);
|
|
if(count>0) {
|
return "1";
|
}
|
return "0";
|
}
|
|
@Override
|
public String addSjzd(HttpServletRequest request) {
|
String categoryid = request.getParameter("cateId");
|
String datakey = request.getParameter("datakey");
|
String datavalue = request.getParameter("datavalue");
|
String beiz = request.getParameter("beiz");
|
String ordernum = request.getParameter("ordernum");
|
|
String insertSql = "INSERT INTO CONFIG_DATA_DICTIONARY (ID,CATEGORYID,DATAKEY,DATAVALUE,BEIZ,ORDERNUM,USESTATE) VALUES (:id,:categoryid,:datakey,:datavalue,:beiz,:ordernum,1)";
|
|
Map paramMap = new HashMap();
|
paramMap.put("id", StringUtil.getUUID());
|
paramMap.put("categoryid", categoryid);
|
paramMap.put("datakey", datakey);
|
paramMap.put("datavalue", datavalue);
|
paramMap.put("beiz", beiz);
|
paramMap.put("ordernum", ordernum);
|
|
baseDao.execute(insertSql, paramMap);
|
|
return "0";
|
}
|
|
@Override
|
public boolean deleteData(String id, String state) {
|
CONFIG_DATA_DICTIONARY data = new CONFIG_DATA_DICTIONARY(id).getInstanceById();
|
dataDictionaryService.updateDataDictionaryByKey(data.getDatakey());
|
data.setUsestate(ConvertUtil.obj2Integer(state)).update();
|
return true;
|
}
|
|
@Override
|
public int sjzdflCount(String pId) {
|
Map paramMap = new HashMap();
|
StringBuilder builder = new StringBuilder(" SELECT COUNT(ID) FROM CONFIG_DATA_DICTIONARY_CATEGORY WHERE USESTATE=1 ");
|
if(StringUtil.notEmpty(pId)) {
|
builder.append(" AND PARENTID = :pId ");
|
paramMap.put("pId", pId);
|
} else {
|
builder.append(" AND PARENTID IS NULL ");
|
}
|
|
|
return baseDao.queryForInteger(builder.toString(), paramMap);
|
}
|
|
@Override
|
public PageInfo sjzdflData(PageInfo pageInfo, HttpServletRequest request) {
|
SqlParameter paramMap=new SqlParameter();
|
String pId = request.getParameter("pId");
|
StringBuilder builder = new StringBuilder(" SELECT * FROM CONFIG_DATA_DICTIONARY_CATEGORY WHERE USESTATE=1 ");
|
if(StringUtil.notEmpty(pId)) {
|
builder.append(" AND PARENTID = :pId ");
|
paramMap.put("pId", pId);
|
} else {
|
builder.append(" AND PARENTID IS NULL ");
|
}
|
|
builder.append(" ORDER BY ORDERNUM");
|
|
return baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), paramMap);
|
}
|
|
|
}
|
