Skip to content
GitLab
Commit 34dcaf3d authored by 季圣华's avatar 季圣华
Browse files

升级代码结构，采用Maven来管理jar包(15)

parent 0b41f71a
Hide whitespace changes
Inline Side-by-side
src/com/jsh/action/asset/AssetAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.asset;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Timestamp;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.util.AssetConstants;
import com.jsh.util.JshException;
import com.jsh.model.po.Asset;
import com.jsh.model.po.Assetname;
import com.jsh.model.po.Basicuser;
import com.jsh.model.po.Logdetails;
import com.jsh.model.po.Supplier;
import com.jsh.model.vo.asset.AssetModel;
import com.jsh.service.asset.AssetIService;
import com.jsh.service.basic.AssetNameIService;
import com.jsh.service.basic.CategoryIService;
import com.jsh.service.basic.SupplierIService;
import com.jsh.service.basic.UserIService;
import com.jsh.util.PageUtil;
import com.jsh.util.Tools;
@SuppressWarnings("serial")
public class AssetAction extends BaseAction<AssetModel>
{
private AssetModel model = new AssetModel();
private AssetIService assetService;
private CategoryIService categoryService;
private SupplierIService supplierService;
private UserIService userService;
private AssetNameIService assetnameService;
@SuppressWarnings({ "rawtypes", "unchecked" })
public String getBasicData()
{
Map<String,List> mapData = model.getShowModel().getMap();
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try
{
Map<String,Object> condition = pageUtil.getAdvSearch();
condition.put("id_s_order", "desc");
categoryService.find(pageUtil);
mapData.put("categoryList", pageUtil.getPageList());
supplierService.find(pageUtil);
mapData.put("supplierList", pageUtil.getPageList());
condition.put("isystem_n_eq", 1);
condition.put("id_s_order", "desc");
userService.find(pageUtil);
mapData.put("userList", pageUtil.getPageList());
//清除搜索条件 防止对查询有影响
condition.remove("isystem_n_eq");
assetnameService.find(pageUtil);
mapData.put("assetnameList", pageUtil.getPageList());
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>查找系统基础数据信息异常", e);
model.getShowModel().setMsgTip("exceptoin");
}
return SUCCESS;
}
/**
* 增加资产
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加资产方法===================");
Boolean flag = false;
try
{
Asset asset = new Asset();
//添加设置
asset.setAssetname(new Assetname(model.getAssetNameID()));
asset.setLocation(model.getLocation());
asset.setStatus(model.getStatus());
asset.setPrice(model.getPrice());
if(null != model.getUserID())
{
asset.setUser( new Basicuser(model.getUserID()));
}
try
{
//购买日期
asset.setPurchasedate(new Timestamp(Tools.parse(model.getPurchasedate(), "yyyy-MM-dd").getTime()));
//有效日期
asset.setPeriodofvalidity(new Timestamp(Tools.parse(model.getPeriodofvalidity(), "yyyy-MM-dd").getTime()));
//保修日期
asset.setWarrantydate(new Timestamp(Tools.parse(model.getWarrantydate(), "yyyy-MM-dd").getTime()));
}
catch (ParseException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>解析购买日期格式异常", e);
}
asset.setAssetnum(model.getAssetnum());
asset.setSerialnum(model.getSerialnum());
asset.setLabels(model.getLabels());
asset.setSupplier( new Supplier(model.getSupplierID()));
asset.setDescription(model.getDescription());
asset.setCreatetime(new Timestamp(new Date().getTime()));
asset.setCreator(getUser());
asset.setUpdatetime(new Timestamp(new Date().getTime()));
asset.setUpdator(getUser());
asset.setAddMonth(Tools.getCurrentMonth());
assetService.create(asset);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加资产异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加资产回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加资产", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加资产名称ID为 "+ model.getAssetNameID() + " " + tipMsg + "！", "增加资产" + tipMsg));
Log.infoFileSync("==================结束调用增加资产方法===================");
}
/**
* 删除资产
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除资产信息方法delete()================");
try
{
assetService.delete(model.getAssetID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getAssetID() + " 的资产异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除资产", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除资产ID为 "+ model.getAssetID() + " " + tipMsg + "！", "删除资产" + tipMsg));
Log.infoFileSync("====================结束调用删除资产信息方法delete()================");
return SUCCESS;
}
/**
* 更新资产
* @return
*/
public void update()
{
Boolean flag = false;
try
{
Asset asset = assetService.get(model.getAssetID());
//设置要更新的熟悉值
asset.setAssetname(new Assetname(model.getAssetNameID()));
asset.setLocation(model.getLocation());
asset.setStatus(model.getStatus());
asset.setPrice(model.getPrice());
if(null != model.getUserID())
asset.setUser(new Basicuser(model.getUserID()));
else
asset.setUser(null);
try
{
//购买日期
asset.setPurchasedate(new Timestamp(Tools.parse(model.getPurchasedate(), "yyyy-MM-dd").getTime()));
//有效日期
asset.setPeriodofvalidity(new Timestamp(Tools.parse(model.getPeriodofvalidity(), "yyyy-MM-dd").getTime()));
//保修日期
asset.setWarrantydate(new Timestamp(Tools.parse(model.getWarrantydate(), "yyyy-MM-dd").getTime()));
}
catch (ParseException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>解析购买日期格式异常", e);
}
asset.setAssetnum(model.getAssetnum());
asset.setSerialnum(model.getSerialnum());
asset.setLabels(model.getLabels());
asset.setSupplier(new Supplier(model.getSupplierID()));
asset.setDescription(model.getDescription());
asset.setUpdatetime(new Timestamp(new Date().getTime()));
asset.setUpdator(getUser());
assetService.update(asset);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改资产ID为 ： " + model.getAssetID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改资产回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新资产", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新资产ID为 "+ model.getAssetID() + " " + tipMsg + "！", "更新资产" + tipMsg));
}
/**
* 批量删除指定ID资产
* @return
*/
public String batchDelete()
{
try
{
assetService.batchDelete(model.getAssetIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除资产ID为：" + model.getAssetIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除资产", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除资产ID为 "+ model.getAssetIDs() + " " + tipMsg + "！", "批量删除资产" + tipMsg));
return SUCCESS;
}
/**
* 查找资产信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Asset> pageUtil = new PageUtil<Asset>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
assetService.find(pageUtil);
getSession().put("pageUtil", pageUtil);
List<Asset> dataList = pageUtil.getPageList();
//开始拼接json数据
// {"total":28,"rows":[
// {"productid":"AV-CB-01","attr1":"Adult Male","itemid":"EST-18"}
// ]}
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Asset asset:dataList)
{
JSONObject item = new JSONObject();
item.put("id", asset.getId());
//添加资产属性
item.put("assetname", asset.getAssetname().getAssetname());
item.put("assetnameID", asset.getAssetname().getId());
//单价
item.put("price", Tools.dealNullStr(asset.getPrice() + ""));
//分类
item.put("category", asset.getAssetname().getCategory().getAssetname());
item.put("categoryID", asset.getAssetname().getCategory().getId());
//资产的状态：0==在库，1==在用，2==消费
item.put("status", getStatusInfo(asset.getStatus()));
item.put("statushort", asset.getStatus());
//在用用户名称
item.put("username", asset.getUser()==null?"":asset.getUser().getUsername());
item.put("userID", asset.getUser()==null?"":asset.getUser().getId());
//位置
item.put("location", Tools.dealNullStr(asset.getLocation()));
//购买日期
item.put("purchasedate", asset.getPurchasedate()==null?"":Tools.getCurrentMonth(asset.getPurchasedate()));
//有效日期
item.put("periodofvalidity", asset.getPeriodofvalidity()==null?"":Tools.getCurrentMonth(asset.getPeriodofvalidity()));
//保修日期
item.put("warrantydate", asset.getWarrantydate()==null?"":Tools.getCurrentMonth(asset.getWarrantydate()));
//资产编号
item.put("assetnum", Tools.dealNullStr(asset.getAssetnum()));
//资产序列号
item.put("serialnum", Tools.dealNullStr(asset.getSerialnum()));
//供应商
item.put("supplier", asset.getSupplier()==null?"":asset.getSupplier().getSupplier());
//供应商
item.put("supplierID", asset.getSupplier()==null?"":asset.getSupplier().getId());
//标签
item.put("labels", Tools.dealNullStr(asset.getLabels()));
item.put("description", Tools.dealNullStr(asset.getDescription()));
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找资产信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询资产信息结果异常", e);
}
}
/**
* 导出excel表格
* @return
*/
@SuppressWarnings("unchecked")
public String exportExcel()
{
Log.infoFileSync("===================调用导出资产信息action方法exportExcel开始=======================");
try
{
PageUtil<Asset> pageUtil = (PageUtil<Asset>)getSession().get("pageUtil");
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
//pageUtil.setAdvSearch(getCondition());
String isCurrentPage = model.getIsAllData();
model.setFileName(Tools.changeUnicode(model.getFileName() + ".xls",model.getBrowserType()));
model.setExcelStream(assetService.exmportExcel(isCurrentPage,pageUtil));
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>>>>调用导出资产信息action方法exportExcel异常",e);
model.getShowModel().setMsgTip("export excel exception");
}
Log.infoFileSync("===================调用导出资产信息action方法exportExcel结束==================");
return AssetConstants.BusinessForExcel.EXCEL;
}
/**
* 导入资产excel表格内容
*/
public String importExcel()
{
//资产excel表格file
Boolean result = false;
String returnStr = "";
try
{
InputStream in = assetService.importExcel(model.getAssetFile(), model.getIsCheck());
if(null != in)
{
model.setFileName(Tools.getRandomChar() + Tools.getNow2(Calendar.getInstance().getTime()) + "_wrong.xls");
model.setExcelStream(in);
returnStr = AssetConstants.BusinessForExcel.EXCEL;
}
else
{
result = true;
try
{
toClient(result.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写导入资产信息结果异常", e);
}
//导入数据成功
returnStr = SUCCESS;
}
}
catch (JshException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>导入excel表格信息异常", e);
}
return returnStr;
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("assetname.id_n_eq", model.getAssetNameID());
condition.put("assetname.category.id_n_eq", model.getAssetCategoryID());
condition.put("user.id_n_eq", model.getUserID());
condition.put("status_n_eq", model.getStatus());
condition.put("supplier.id_n_eq", model.getSupplierID());
condition.put("createtime_s_order", "desc");
return condition;
}
/**
* 根据状态码转化成说明字符串
* 资产的状态：0==在库，1==在用，2==消费
* @param statusCode
* @return
*/
private String getStatusInfo(short statusCode)
{
String statusInfo = "";
switch(statusCode)
{
case AssetConstants.BusinessForExcel.EXCEl_STATUS_ZAIKU:
statusInfo = "在库";
break;
case AssetConstants.BusinessForExcel.EXCEl_STATUS_INUSE:
statusInfo = "在用";
break;
case AssetConstants.BusinessForExcel.EXCEl_STATUS_CONSUME:
statusInfo = "消费";
break;
}
return statusInfo;
}
//=========Spring注入以及model驱动公共方法===========
public void setAssetService(AssetIService assetService)
{
this.assetService = assetService;
}
public void setCategoryService(CategoryIService categoryService)
{
this.categoryService = categoryService;
}
public void setSupplierService(SupplierIService supplierService)
{
this.supplierService = supplierService;
}
public void setUserService(UserIService userService)
{
this.userService = userService;
}
public void setAssetnameService(AssetNameIService assetnameService)
{
this.assetnameService = assetnameService;
}
@Override
public AssetModel getModel()
{
return model;
}
}
src/com/jsh/action/asset/ReportAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.asset;
import java.util.HashMap;
import java.util.Map;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.util.JshException;
import com.jsh.model.po.Asset;
import com.jsh.model.vo.asset.ReportModel;
import com.jsh.service.asset.ReportIService;
import com.jsh.util.PageUtil;
@SuppressWarnings("serial")
public class ReportAction extends BaseAction<ReportModel>
{
private ReportModel model = new ReportModel();
private ReportIService reportService;
/**
* 查找资产信息
* @return
*/
public String find()
{
try
{
PageUtil<Asset> pageUtil = new PageUtil<Asset>();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
pageUtil.setAdvSearch(getCondition());
String reportType = getReportType(new HashMap<String,Object>());
reportService.find(pageUtil,reportType.split("_")[0],reportType.split("_")[1]);
model.getShowModel().setReportData(pageUtil.getPageList());
}
catch (JshException e)
{
Log.errorFileSync(">>>>>>>>>查找资产信息异常", e);
model.getShowModel().setMsgTip("get report data exception");
}
return SUCCESS;
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("assetname.id_n_eq", model.getAssetNameID());
condition.put("assetname.category.id_n_eq", model.getAssetCategoryID());
condition.put("user.id_n_eq", model.getUsernameID());
condition.put("status_n_eq", model.getStatus());
condition.put("supplier.id_n_eq", model.getSupplierID());
condition.put("dataSum_s_order","desc");
//拼接统计数据条件
getReportType(condition);
return condition;
}
/**
* 获取统计条件
* @param condition
*/
private String getReportType(Map<String,Object> condition)
{
// <option value="0">资产状态</option>
// <option value="1">资产类型</option>
// <option value="2">供应商</option>
// <option value="3">资产名称</option>
// <option value="4">所属用户</option>
int reportType = model.getReportType();
String reportTypeInfo = "";
String reportTypeName = "";
switch(reportType)
{
case 0:
condition.put("status_s_gb", "group");
reportTypeInfo = "status";
reportTypeName = "status";
break;
case 1:
condition.put("assetname.category.id_s_gb", "group");
reportTypeInfo = "assetname.category.id";
reportTypeName = "assetname.category.assetname";
break;
case 2:
condition.put("supplier.id_s_gb", "group");
reportTypeInfo = "supplier.id";
reportTypeName = "supplier.supplier";
break;
case 3:
condition.put("assetname.id_s_gb", "group");
reportTypeInfo = "assetname.id";
reportTypeName = "assetname.assetname";
break;
case 4:
condition.put("user.id_s_gb", "group");
reportTypeInfo = "user.id";
reportTypeName = "user.username";
break;
}
return reportTypeInfo + "_" + reportTypeName;
}
//=========Spring注入以及model驱动公共方法===========
public void setReportService(ReportIService reportService)
{
this.reportService = reportService;
}
@Override
public ReportModel getModel()
{
return model;
}
}
src/com/jsh/action/basic/AccountAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.DepotHead;
import com.jsh.model.po.Logdetails;
import com.jsh.model.po.Account;
import com.jsh.model.vo.basic.AccountModel;
import com.jsh.service.basic.AccountIService;
import com.jsh.service.materials.DepotHeadIService;
import com.jsh.util.PageUtil;
import com.jsh.util.Tools;
/**
* 结算账户
* @author ji sheng hua qq752718920
*/
@SuppressWarnings("serial")
public class AccountAction extends BaseAction<AccountModel>
{
private AccountIService accountService;
private DepotHeadIService depotHeadService;
private AccountModel model = new AccountModel();
@SuppressWarnings({ "rawtypes", "unchecked" })
public String getAccount()
{
Map<String,List> mapData = model.getShowModel().getMap();
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try
{
Map<String,Object> condition = pageUtil.getAdvSearch();
condition.put("Id_s_order", "asc");
accountService.find(pageUtil);
mapData.put("accountList", pageUtil.getPageList());
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>查找账户信息异常", e);
model.getShowModel().setMsgTip("exception");
}
return SUCCESS;
}
/**
* 增加结算账户
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加结算账户方法===================");
Boolean flag = false;
try
{
Account Account = new Account();
Account.setName(model.getName());
Account.setSerialNo(model.getSerialNo());
Account.setInitialAmount(model.getInitialAmount()!=null ? model.getInitialAmount() : 0);
Account.setCurrentAmount(model.getCurrentAmount());
Account.setRemark(model.getRemark());
accountService.create(Account);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加结算账户异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加结算账户回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加结算账户", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加结算账户名称为 "+ model.getName() + " " + tipMsg + "！", "增加结算账户" + tipMsg));
Log.infoFileSync("==================结束调用增加结算账户方法===================");
}
/**
* 删除结算账户
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除结算账户信息方法delete()================");
try
{
accountService.delete(model.getAccountID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getAccountID() + " 的结算账户异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除结算账户", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除结算账户ID为 "+ model.getAccountID() + ",名称为 " + model.getName() + tipMsg + "！", "删除结算账户" + tipMsg));
Log.infoFileSync("====================结束调用删除结算账户信息方法delete()================");
return SUCCESS;
}
/**
* 更新结算账户
* @return
*/
public void update()
{
Boolean flag = false;
try
{
Account Account = accountService.get(model.getAccountID());
Account.setName(model.getName());
Account.setSerialNo(model.getSerialNo());
Account.setInitialAmount(model.getInitialAmount()!=null ? model.getInitialAmount() : 0);
Account.setCurrentAmount(model.getCurrentAmount());
Account.setRemark(model.getRemark());
accountService.update(Account);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改结算账户ID为 ： " + model.getAccountID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改结算账户回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新结算账户", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新结算账户ID为 "+ model.getAccountID() + " " + tipMsg + "！", "更新结算账户" + tipMsg));
}
/**
* 更新结算账户金额
* @return
*/
public void updateAmount()
{
Boolean flag = false;
try
{
Account Account = accountService.get(model.getAccountID());
Account.setCurrentAmount(model.getCurrentAmount());
accountService.update(Account);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改结算账户ID为 ： " + model.getAccountID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改结算账户回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新结算账户", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新结算账户ID为 "+ model.getAccountID() + " " + tipMsg + "！", "更新结算账户" + tipMsg));
}
/**
* 批量删除指定ID结算账户
* @return
*/
public String batchDelete()
{
try
{
accountService.batchDelete(model.getAccountIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除结算账户ID为：" + model.getAccountIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除结算账户", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除结算账户ID为 "+ model.getAccountIDs() + " " + tipMsg + "！", "批量删除结算账户" + tipMsg));
return SUCCESS;
}
/**
* 检查输入名称是否存在
*/
public void checkIsNameExist()
{
Boolean flag = false;
try
{
flag = accountService.checkIsNameExist("name", model.getName(), "id", model.getAccountID());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查结算账户名称为：" + model.getName() + " ID为： " + model.getAccountID() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查结算账户名称为：" + model.getName() + " ID为： " + model.getAccountID() + " 是否存在异常！",e);
}
}
}
/**
* 查找结算账户信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Account> pageUtil = new PageUtil<Account>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
accountService.find(pageUtil);
List<Account> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Account account:dataList)
{
JSONObject item = new JSONObject();
item.put("id", account.getId());
//结算账户名称
item.put("name", account.getName());
item.put("serialNo", account.getSerialNo());
item.put("initialAmount", account.getInitialAmount());
String monthTime = Tools.getCurrentMonth();
item.put("thisMonthAmount", getAccountSum(account.getId(),monthTime)); //本月发生额
item.put("currentAmount", getAccountSum(account.getId(),"") + account.getInitialAmount()); //当前余额
item.put("remark", account.getRemark());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找结算账户信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询结算账户信息结果异常", e);
}
}
/**
* 单个账户的金额求和
* @param id
* @return
*/
public Double getAccountSum(Long id,String monthTime){
Double accountSum = 0.0;
try{
PageUtil<DepotHead> pageUtil = new PageUtil<DepotHead>();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
pageUtil.setAdvSearch(getCondition_getSum(id,monthTime));
depotHeadService.find(pageUtil);
List<DepotHead> dataList = pageUtil.getPageList();
if(dataList!= null){
for(DepotHead depotHead:dataList){
accountSum = accountSum + depotHead.getChangeAmount();
}
}
}
catch (DataAccessException e){
Log.errorFileSync(">>>>>>>>>查找进销存信息异常", e);
}
return accountSum;
}
/**
* 查找结算账户信息-下拉框
* @return
*/
public void findBySelect()
{
try
{
PageUtil<Account> pageUtil = new PageUtil<Account>();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
pageUtil.setAdvSearch(getCondition_select());
accountService.find(pageUtil);
List<Account> dataList = pageUtil.getPageList();
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Account account:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", account.getId());
//结算账户名称
item.put("AccountName", account.getName());
dataArray.add(item);
}
}
//回写查询结果
toClient(dataArray.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找结算账户信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询结算账户信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("name_s_like", model.getName());
condition.put("serialNo_s_like", model.getSerialNo());
condition.put("remark_s_like", model.getRemark());
condition.put("id_s_order", "desc");
return condition;
}
/**
* 拼接搜索条件-下拉框-结算账户
* @return
*/
private Map<String,Object> getCondition_select()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("id_s_order", "desc");
return condition;
}
/**
* 拼接搜索条件-结算账户当前余额求和
* @return
*/
private Map<String,Object> getCondition_getSum(Long id,String monthTime)
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("AccountId_n_eq", id);
if(!monthTime.equals("")){
condition.put("OperTime_s_gteq", monthTime + "-01 00:00:00");
condition.put("OperTime_s_lteq", monthTime + "-31 00:00:00");
}
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public AccountModel getModel()
{
return model;
}
public void setAccountService(AccountIService accountService)
{
this.accountService = accountService;
}
public void setDepotHeadService(DepotHeadIService depotHeadService) {
this.depotHeadService = depotHeadService;
}
}
src/com/jsh/action/basic/AppAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.struts2.ServletActionContext;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.util.JshException;
import com.jsh.model.po.App;
import com.jsh.model.po.Logdetails;
import com.jsh.model.vo.basic.AppModel;
import com.jsh.service.basic.AppIService;
import com.jsh.service.basic.UserBusinessIService;
import com.jsh.util.PageUtil;
/**
* 应用
* @author ji_sheng_hua qq752 718 920
*/
@SuppressWarnings("serial")
public class AppAction extends BaseAction<AppModel>
{
private AppIService appService;
private UserBusinessIService userBusinessService;
private AppModel model = new AppModel();
/**
* 增加应用
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加应用方法create()===================");
Boolean flag = false;
try
{
App app = new App();
app.setNumber(model.getNumber());
app.setName(model.getName());
app.setType(model.getType());
try {
if(model.getIcon()!=null)
{
String path = ServletActionContext.getServletContext().getRealPath("/upload/images/deskIcon");
String iconName=model.getIcon();
File file1 = new File(iconName); //文件
String FileName = file1.getName(); //获取文件名
app.setIcon(FileName); //设置图片ICON
InputStream is = new FileInputStream(iconName);
File file = new File(path, FileName);
OutputStream os = new FileOutputStream(file);
byte[] b = new byte[1024];
int bs = 0;
while ((bs = is.read(b)) > 0) {
os.write(b, 0, bs);
}
is.close();
os.close();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
app.setURL(model.getURL());
app.setWidth(model.getWidth());
app.setHeight(model.getHeight());
app.setReSize(model.getReSize());
app.setOpenMax(model.getOpenMax());
app.setFlash(model.getFlash());
app.setZL(model.getZL());
app.setSort(model.getSort());
app.setRemark(model.getRemark());
app.setEnabled(model.getEnabled());
appService.create(app);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加应用异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加应用回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加应用", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加应用名称为 "+ model.getName() + " " + tipMsg + "！", "增加应用" + tipMsg));
Log.infoFileSync("==================结束调用增加应用方法create()===================");
}
/**
* 删除应用
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除应用方法delete()================");
try
{
appService.delete(model.getAppID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getAppID() + " 的应用异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除应用", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除应用ID为 "+ model.getAppID() + " " + tipMsg + "！", "删除应用" + tipMsg));
Log.infoFileSync("====================结束调用删除应用方法delete()================");
return SUCCESS;
}
/**
* 更新仓库
* @return
*/
public void update()
{
Boolean flag = false;
try
{
App app = appService.get(model.getAppID());
app.setNumber(model.getNumber());
app.setName(model.getName());
app.setType(model.getType());
//app.setIcon(model.getIcon());
app.setURL(model.getURL());
app.setWidth(model.getWidth());
app.setHeight(model.getHeight());
app.setReSize(model.getReSize());
app.setOpenMax(model.getOpenMax());
app.setFlash(model.getFlash());
app.setZL(model.getZL());
app.setSort(model.getSort());
app.setRemark(model.getRemark());
app.setEnabled(model.getEnabled());
appService.update(app);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改应用ID为 ： " + model.getAppID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改应用回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新应用", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新应用ID为 "+ model.getAppID() + " " + tipMsg + "！", "更新应用" + tipMsg));
}
/**
* 批量删除指定ID应用
* @return
*/
public String batchDelete()
{
try
{
appService.batchDelete(model.getAppIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除应用ID为：" + model.getAppIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除应用", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除应用ID为 "+ model.getAppIDs() + " " + tipMsg + "！", "批量删除应用" + tipMsg));
return SUCCESS;
}
/**
* 检查输入名称是否存在
*/
public void checkIsNameExist()
{
Boolean flag = false;
try
{
flag = appService.checkIsNameExist("name",model.getName(),"Id", model.getAppID());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查应用名称为：" + model.getName() + " ID为： " + model.getAppID() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查应用名称为：" + model.getName() + " ID为： " + model.getAppID() + " 是否存在异常！",e);
}
}
}
/**
* 查找应用信息
* @return
*/
public void findBy()
{
try
{
PageUtil<App> pageUtil = new PageUtil<App>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
appService.find(pageUtil);
List<App> dataList = pageUtil.getPageList();
//开始拼接json数据
// {"total":28,"rows":[
// {"productid":"AV-CB-01","attr1":"Adult Male","itemid":"EST-18"}
// ]}
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(App app:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", app.getId());
//应用名称
item.put("Number", app.getNumber());
item.put("Name", app.getName());
item.put("Type", app.getType());
item.put("Icon", app.getIcon());
item.put("URL", app.getURL());
item.put("Width", app.getWidth());
item.put("Height", app.getHeight());
item.put("ReSize", app.getReSize());
item.put("OpenMax", app.getOpenMax());
item.put("Flash", app.getFlash());
item.put("ZL", app.getZL());
item.put("Sort", app.getSort());
item.put("Remark", app.getRemark());
item.put("Enabled", app.getEnabled());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找应用异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询应用结果异常", e);
}
}
/**
* 桌面应用显示
* @return
*/
public void findDesk()
{
try
{
PageUtil<App> pageUtil = new PageUtil<App>();
pageUtil.setPageSize(100);
//pageUtil.setCurPage(model.getPageNo());
JSONObject outer = new JSONObject();
//下面是dock
pageUtil.setAdvSearch(getCondition_dock());
appService.find(pageUtil);
List<App> dataList1 = pageUtil.getPageList();
//开始拼接json数据
//存放数据json数组
JSONArray dataArray1 = new JSONArray();
if(null != dataList1)
{
for(App app:dataList1)
{
JSONObject item = new JSONObject();
item.put("id", app.getId());
item.put("title", app.getName());
item.put("type", app.getType());
item.put("icon", "../../upload/images/deskIcon/"+app.getIcon());
item.put("url", app.getURL());
item.put("width", app.getWidth());
item.put("height", app.getHeight());
item.put("isresize", app.getReSize());
item.put("isopenmax", app.getOpenMax());
item.put("isflash", app.getFlash());
dataArray1.add(item);
}
}
outer.put("dock", dataArray1);
//下面是desk
pageUtil.setAdvSearch(getCondition_desk());
appService.find(pageUtil);
List<App> dataList2 = pageUtil.getPageList();
//开始拼接json数据
//存放数据json数组
JSONArray dataArray2 = new JSONArray();
if(null != dataList2)
{
for(App app:dataList2)
{
JSONObject item = new JSONObject();
item.put("id", app.getId());
item.put("title", app.getName());
item.put("type", app.getType());
item.put("icon", "../../upload/images/deskIcon/"+app.getIcon());
item.put("url", "../../pages/common/menu.jsp?appID="+app.getNumber()+"&id="+app.getId());
item.put("width", app.getWidth());
item.put("height", app.getHeight());
item.put("isresize", app.getReSize());
item.put("isopenmax", app.getOpenMax());
item.put("isflash", app.getFlash());
dataArray2.add(item);
}
}
outer.put("desk", dataArray2);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找应用异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询应用结果异常", e);
}
}
/**
* 角色对应应用显示
* @return
*/
public void findRoleAPP()
{
try
{
PageUtil<App> pageUtil = new PageUtil<App>();
pageUtil.setPageSize(100);
//pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition_RoleAPP());
appService.find(pageUtil);
List<App> dataList = pageUtil.getPageList();
//开始拼接json数据
JSONObject outer = new JSONObject();
outer.put("id", 1);
outer.put("text", "应用列表");
outer.put("state", "open");
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(App app:dataList)
{
JSONObject item = new JSONObject();
item.put("id", app.getId());
item.put("text", app.getName());
//勾选判断1
Boolean flag = false;
try
{
flag = userBusinessService.checkIsUserBusinessExist("Type",model.getUBType(),"KeyId",model.getUBKeyId(),"Value","["+app.getId().toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>设置角色对应的应用：类型" + model.getUBType() + " KeyId为： " + model.getUBKeyId() + " 存在异常！");
}
if (flag==true){item.put("checked", true);}
//结束
dataArray.add(item);
}
}
outer.put("children", dataArray);
//回写查询结果
toClient("["+outer.toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找应用异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询应用结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("Name_s_like", model.getName());
condition.put("Type_s_like", model.getType());
condition.put("Sort_s_order", "asc");
return condition;
}
/**
* 拼接搜索条件-桌面dock
* @return
*/
private Map<String,Object> getCondition_dock()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("ZL_s_eq", "dock");
condition.put("Enabled_n_eq", 1);
condition.put("Sort_s_order", "asc");
return condition;
}
/**
* 拼接搜索条件-桌面desk
* @return
*/
private Map<String,Object> getCondition_desk()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("ZL_s_eq", "desk");
condition.put("Enabled_n_eq", 1);
condition.put("Sort_s_order", "asc");
return condition;
}
/**
* 拼接搜索条件-角色对应应用
* @return
*/
private Map<String,Object> getCondition_RoleAPP()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("Enabled_n_eq", 1);
condition.put("Sort_s_order", "asc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public AppModel getModel()
{
return model;
}
public void setAppService(AppIService appService)
{
this.appService = appService;
}
public void setUserBusinessService(UserBusinessIService userBusinessService) {
this.userBusinessService = userBusinessService;
}
}
src/com/jsh/action/basic/AssetNameAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.Assetname;
import com.jsh.model.po.Category;
import com.jsh.model.po.Logdetails;
import com.jsh.model.vo.basic.AssetNameModel;
import com.jsh.service.basic.AssetNameIService;
import com.jsh.util.PageUtil;
@SuppressWarnings("serial")
public class AssetNameAction extends BaseAction<AssetNameModel>
{
private AssetNameModel model = new AssetNameModel();
private AssetNameIService assetnameService;
/**
* 增加资产名称
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加资产名称方法create()===================");
Boolean flag = false;
try
{
Assetname assetname = new Assetname();
assetname.setAssetname(model.getAssetName());
//增加资产类型
assetname.setCategory(new Category(model.getCategoryID()));
assetname.setIsystem((short)1);
assetname.setIsconsumables(model.getConsumable());
assetname.setDescription(model.getDescription());
assetnameService.create(assetname);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加资产名称异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加资产名称回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加资产名称", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加资产名称名称为 "+ model.getAssetName() + " " + tipMsg + "！", "增加资产名称" + tipMsg));
Log.infoFileSync("==================结束调用增加资产名称方法create()===================");
}
/**
* 删除资产名称
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除资产名称信息方法delete()================");
try
{
assetnameService.delete(model.getAssetNameID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getAssetNameID() + " 的资产名称异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除资产名称", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除资产名称ID为 "+ model.getAssetNameID() + " " + tipMsg + "！", "删除资产名称" + tipMsg));
Log.infoFileSync("====================结束调用删除资产名称信息方法delete()================");
return SUCCESS;
}
/**
* 更新资产名称
* @return
*/
public void update()
{
Boolean flag = false;
try
{
Assetname assetname = assetnameService.get(model.getAssetNameID());
//增加资产类型
assetname.setCategory(new Category(model.getCategoryID()));
assetname.setAssetname(model.getAssetName());
assetname.setIsconsumables(model.getConsumable());
assetname.setDescription(model.getDescription());
assetnameService.update(assetname);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改资产名称ID为 ： " + model.getAssetNameID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改资产名称回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新资产名称", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新资产名称ID为 "+ model.getAssetNameID() + " " + tipMsg + "！", "更新资产名称" + tipMsg));
}
/**
* 批量删除指定ID资产名称
* @return
*/
public String batchDelete()
{
try
{
assetnameService.batchDelete(model.getAssetNameIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除资产名称ID为：" + model.getAssetNameIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除资产名称", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除资产名称ID为 "+ model.getAssetNameIDs() + " " + tipMsg + "！", "批量删除资产名称" + tipMsg));
return SUCCESS;
}
/**
* 检查输入名称是否存在
*/
public void checkIsNameExist()
{
Boolean flag = false;
try
{
flag = assetnameService.checkIsNameExist("assetname",model.getAssetName(),"id", model.getAssetNameID());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查资产名称名称为：" + model.getAssetName() + " ID为： " + model.getAssetNameID() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查资产名称名称为：" + model.getAssetName() + " ID为： " + model.getAssetNameID() + " 是否存在异常！",e);
}
}
}
/**
* 查找供应商信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Assetname> pageUtil = new PageUtil<Assetname>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
assetnameService.find(pageUtil);
List<Assetname> dataList = pageUtil.getPageList();
//开始拼接json数据
// {"total":28,"rows":[
// {"productid":"AV-CB-01","attr1":"Adult Male","itemid":"EST-18"}
// ]}
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Assetname assetname:dataList)
{
JSONObject item = new JSONObject();
item.put("id", assetname.getId());
//供应商名称
item.put("assetname", assetname.getAssetname());
item.put("isystem", assetname.getIsystem() == (short)0?"是":"否");
item.put("consumable", assetname.getIsconsumables() == (short)0?"是":"否");
item.put("consumableStatus", assetname.getIsconsumables());
item.put("description", assetname.getDescription());
item.put("categoryID", assetname.getCategory().getId());
item.put("category", assetname.getCategory().getAssetname());
item.put("op", assetname.getIsystem());
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找资产名称信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询资产名称信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("assetname_s_like", model.getAssetName());
condition.put("isconsumables_n_eq", model.getConsumable());
condition.put("description_s_like", model.getDescription());
condition.put("category.id_n_eq", model.getCategoryID());
condition.put("id_s_order", "desc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public AssetNameModel getModel()
{
return model;
}
public void setAssetnameService(AssetNameIService assetnameService)
{
this.assetnameService = assetnameService;
}
}
src/com/jsh/action/basic/CategoryAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.Category;
import com.jsh.model.po.Logdetails;
import com.jsh.model.vo.basic.CategoryModel;
import com.jsh.service.basic.CategoryIService;
import com.jsh.util.PageUtil;
/*
* @author jishenghua qq:7-5-2-7-1-8-9-2-0
*/
@SuppressWarnings("serial")
public class CategoryAction extends BaseAction<CategoryModel>
{
private CategoryIService categoryService;
private CategoryModel model = new CategoryModel();
/**
* 增加资产类型
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加资产类型方法create()===================");
Boolean flag = false;
try
{
Category category = new Category();
category.setAssetname(model.getCategoryName());
category.setIsystem((short)1);
category.setDescription(model.getDescription());
categoryService.create(category);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加资产类型异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加资产类型回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加资产类型", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加资产类型名称为 "+ model.getCategoryName() + " " + tipMsg + "！", "增加资产类型" + tipMsg));
Log.infoFileSync("==================结束调用增加资产类型方法create()===================");
}
/**
* 删除资产类型
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除资产类型信息方法delete()================");
try
{
categoryService.delete(model.getCategoryID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getCategoryID() + " 的资产类型异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除资产类型", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除资产类型ID为 "+ model.getCategoryID() + " " + tipMsg + "！", "删除资产类型" + tipMsg));
Log.infoFileSync("====================结束调用删除资产类型信息方法delete()================");
return SUCCESS;
}
/**
* 更新资产类型
* @return
*/
public void update()
{
Boolean flag = false;
try
{
Category category = categoryService.get(model.getCategoryID());
category.setAssetname(model.getCategoryName());
category.setDescription(model.getDescription());
categoryService.update(category);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改资产类型ID为 ： " + model.getCategoryID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改资产类型回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新资产类型", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新资产类型ID为 "+ model.getCategoryID() + " " + tipMsg + "！", "更新资产类型" + tipMsg));
}
/**
* 批量删除指定ID资产类型
* @return
*/
public String batchDelete()
{
try
{
categoryService.batchDelete(model.getCategoryIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除资产类型ID为：" + model.getCategoryIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除资产类型", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除资产类型ID为 "+ model.getCategoryIDs() + " " + tipMsg + "！", "批量删除资产类型" + tipMsg));
return SUCCESS;
}
/**
* 检查输入名称是否存在
*/
public void checkIsNameExist()
{
Boolean flag = false;
try
{
flag = categoryService.checkIsNameExist("assetname",model.getCategoryName(),"id", model.getCategoryID());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查资产类型名称为：" + model.getCategoryName() + " ID为： " + model.getCategoryID() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查资产类型名称为：" + model.getCategoryName() + " ID为： " + model.getCategoryID() + " 是否存在异常！",e);
}
}
}
/**
* 查找供应商信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Category> pageUtil = new PageUtil<Category>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
categoryService.find(pageUtil);
List<Category> dataList = pageUtil.getPageList();
//开始拼接json数据
// {"total":28,"rows":[
// {"productid":"AV-CB-01","attr1":"Adult Male","itemid":"EST-18"}
// ]}
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Category category:dataList)
{
JSONObject item = new JSONObject();
item.put("id", category.getId());
//供应商名称
item.put("categoryname", category.getAssetname());
item.put("isystem", category.getIsystem() == (short)0?"是":"否");
item.put("description", category.getDescription());
item.put("op", category.getIsystem());
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找资产类型信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询资产类型信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("assetname_s_like", model.getCategoryName());
condition.put("description_s_like", model.getDescription());
condition.put("id_s_order", "desc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public CategoryModel getModel()
{
return model;
}
public void setCategoryService(CategoryIService categoryService)
{
this.categoryService = categoryService;
}
}
src/com/jsh/action/basic/DepotAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.util.JshException;
import com.jsh.model.po.Depot;
import com.jsh.model.po.Logdetails;
import com.jsh.model.po.Role;
import com.jsh.model.vo.basic.DepotModel;
import com.jsh.service.basic.DepotIService;
import com.jsh.service.basic.UserBusinessIService;
import com.jsh.util.PageUtil;
/**
* 仓库管理
* @author jishenghua qq:7-5-2-7-1-8-9-2-0
*/
@SuppressWarnings("serial")
public class DepotAction extends BaseAction<DepotModel>
{
private DepotIService depotService;
private UserBusinessIService userBusinessService;
private DepotModel model = new DepotModel();
@SuppressWarnings({ "rawtypes", "unchecked" })
public String getBasicData()
{
Map<String,List> mapData = model.getShowModel().getMap();
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try
{
Map<String,Object> condition = pageUtil.getAdvSearch();
condition.put("sort_s_order", "asc");
depotService.find(pageUtil);
mapData.put("depotList", pageUtil.getPageList());
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>查找系统基础数据信息异常", e);
model.getShowModel().setMsgTip("exceptoin");
}
return SUCCESS;
}
/**
* 增加仓库
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加仓库信息方法create()===================");
Boolean flag = false;
try
{
Depot depot = new Depot();
depot.setName(model.getName());
depot.setSort(model.getSort());
depot.setRemark(model.getRemark());
depotService.create(depot);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加仓库信息异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加仓库信息回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加仓库", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加仓库名称为 "+ model.getName() + " " + tipMsg + "！", "增加仓库" + tipMsg));
Log.infoFileSync("==================结束调用增加仓库方法create()===================");
}
/**
* 删除仓库
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除仓库信息方法delete()================");
try
{
depotService.delete(model.getDepotID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getDepotID() + " 的仓库异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除仓库", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除仓库ID为 "+ model.getDepotID() + " " + tipMsg + "！", "删除仓库" + tipMsg));
Log.infoFileSync("====================结束调用删除仓库信息方法delete()================");
return SUCCESS;
}
/**
* 更新仓库
* @return
*/
public void update()
{
Boolean flag = false;
try
{
Depot depot = depotService.get(model.getDepotID());
depot.setName(model.getName());
depot.setSort(model.getSort());
depot.setRemark(model.getRemark());
depotService.update(depot);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改仓库ID为 ： " + model.getDepotID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改仓库回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新仓库", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新仓库ID为 "+ model.getDepotID() + " " + tipMsg + "！", "更新仓库" + tipMsg));
}
/**
* 批量删除指定ID仓库
* @return
*/
public String batchDelete()
{
try
{
depotService.batchDelete(model.getDepotIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除仓库ID为：" + model.getDepotIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除仓库", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除仓库ID为 "+ model.getDepotIDs() + " " + tipMsg + "！", "批量删除仓库" + tipMsg));
return SUCCESS;
}
/**
* 检查输入名称是否存在
*/
public void checkIsNameExist()
{
Boolean flag = false;
try
{
flag = depotService.checkIsNameExist("name",model.getName(),"id", model.getDepotID());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查仓库名称为：" + model.getName() + " ID为： " + model.getDepotID() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查仓库名称为：" + model.getName() + " ID为： " + model.getDepotID() + " 是否存在异常！",e);
}
}
}
/**
* 查找仓库信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Depot> pageUtil = new PageUtil<Depot>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
depotService.find(pageUtil);
List<Depot> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Depot depot:dataList)
{
JSONObject item = new JSONObject();
item.put("id", depot.getId());
//供应商名称
item.put("name", depot.getName());
item.put("sort", depot.getSort());
item.put("remark", depot.getRemark());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找仓库信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询仓库信息结果异常", e);
}
}
/**
* 用户对应仓库显示
* @return
*/
public void findUserDepot()
{
try
{
PageUtil<Depot> pageUtil = new PageUtil<Depot>();
pageUtil.setPageSize(100);
//pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition_UserDepot());
depotService.find(pageUtil);
List<Depot> dataList = pageUtil.getPageList();
//开始拼接json数据
JSONObject outer = new JSONObject();
outer.put("id", 1);
outer.put("text", "仓库列表");
outer.put("state", "open");
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Depot depot:dataList)
{
JSONObject item = new JSONObject();
item.put("id", depot.getId());
item.put("text", depot.getName());
//勾选判断1
Boolean flag = false;
try
{
flag = userBusinessService.checkIsUserBusinessExist("Type",model.getUBType(),"KeyId",model.getUBKeyId(),"Value","["+depot.getId().toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>设置用户对应的仓库：类型" + model.getUBType() + " KeyId为： " + model.getUBKeyId() + " 存在异常！");
}
if (flag==true){item.put("checked", true);}
//结束
dataArray.add(item);
}
}
outer.put("children", dataArray);
//回写查询结果
toClient("["+outer.toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找仓库异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询仓库结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("name_s_like", model.getName());
condition.put("remark_s_like", model.getRemark());
condition.put("sort_s_order", "asc");
return condition;
}
/**
* 拼接搜索条件-用户对应部门
* @return
*/
private Map<String,Object> getCondition_UserDepot()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("sort_s_order", "asc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public DepotModel getModel()
{
return model;
}
public void setDepotService(DepotIService depotService)
{
this.depotService = depotService;
}
public void setUserBusinessService(UserBusinessIService userBusinessService) {
this.userBusinessService = userBusinessService;
}
}
src/com/jsh/action/basic/FunctionsAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.util.JshException;
import com.jsh.model.po.App;
import com.jsh.model.po.Functions;
import com.jsh.model.po.Logdetails;
import com.jsh.model.vo.basic.FunctionsModel;
import com.jsh.service.basic.FunctionsIService;
import com.jsh.service.basic.UserBusinessIService;
import com.jsh.util.PageUtil;
/*
* 功能管理
* @author jishenghua qq:7-5-2-7-1-8-9-2-0
*/
@SuppressWarnings("serial")
public class FunctionsAction extends BaseAction<FunctionsModel>
{
private FunctionsIService functionsService;
private UserBusinessIService userBusinessService;
private FunctionsModel model = new FunctionsModel();
/**
* 增加功能
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加功能信息方法create()===================");
Boolean flag = false;
try
{
Functions functions = new Functions();
functions.setNumber(model.getNumber());
functions.setName(model.getName());
functions.setPNumber(model.getPNumber());
functions.setURL(model.getURL());
functions.setState(model.getState());
functions.setSort(model.getSort());
functions.setEnabled(model.getEnabled());
functions.setType(model.getType());
functionsService.create(functions);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加功能信息异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加功能信息回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加功能", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加功能名称为 "+ model.getName() + " " + tipMsg + "！", "增加功能" + tipMsg));
Log.infoFileSync("==================结束调用增加功能方法create()===================");
}
/**
* 删除功能
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除功能信息方法delete()================");
try
{
functionsService.delete(model.getFunctionsID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getFunctionsID() + " 的功能异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除功能", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除功能ID为 "+ model.getFunctionsID() + " " + tipMsg + "！", "删除功能" + tipMsg));
Log.infoFileSync("====================结束调用删除功能信息方法delete()================");
return SUCCESS;
}
/**
* 更新功能
* @return
*/
public void update()
{
Boolean flag = false;
try
{
Functions functions = functionsService.get(model.getFunctionsID());
functions.setNumber(model.getNumber());
functions.setName(model.getName());
functions.setPNumber(model.getPNumber());
functions.setURL(model.getURL());
functions.setState(model.getState());
functions.setSort(model.getSort());
functions.setEnabled(model.getEnabled());
functions.setType(model.getType());
functionsService.update(functions);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改功能ID为 ： " + model.getFunctionsID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改功能回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新功能", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新功能ID为 "+ model.getFunctionsID() + " " + tipMsg + "！", "更新功能" + tipMsg));
}
/**
* 批量删除指定ID功能
* @return
*/
public String batchDelete()
{
try
{
functionsService.batchDelete(model.getFunctionsIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除功能ID为：" + model.getFunctionsIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除功能", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除功能ID为 "+ model.getFunctionsIDs() + " " + tipMsg + "！", "批量删除功能" + tipMsg));
return SUCCESS;
}
/**
* 检查输入名称是否存在
*/
public void checkIsNameExist()
{
Boolean flag = false;
try
{
flag = functionsService.checkIsNameExist("Name",model.getName(),"Id", model.getFunctionsID());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查功能名称为：" + model.getName() + " ID为： " + model.getFunctionsID() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查功能名称为：" + model.getName() + " ID为： " + model.getFunctionsID() + " 是否存在异常！",e);
}
}
}
/**
* 查找功能信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Functions> pageUtil = new PageUtil<Functions>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
functionsService.find(pageUtil);
List<Functions> dataList = pageUtil.getPageList();
//开始拼接json数据
// {"total":28,"rows":[
// {"productid":"AV-CB-01","attr1":"Adult Male","itemid":"EST-18"}
// ]}
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Functions functions:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", functions.getId());
item.put("Number", functions.getNumber());
item.put("Name", functions.getName());
item.put("PNumber", functions.getPNumber());
item.put("URL", functions.getURL());
item.put("State", functions.getState());
item.put("Sort", functions.getSort());
item.put("Enabled", functions.getEnabled());
item.put("Type", functions.getType());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找功能信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询功能信息结果异常", e);
}
}
/**
* 角色对应功能显示
* @return
*/
public void findRoleFunctions()
{
try
{
PageUtil<Functions> pageUtil = new PageUtil<Functions>();
pageUtil.setPageSize(200);
pageUtil.setAdvSearch(getCondition_RoleFunctions("0"));
functionsService.find(pageUtil);
List<Functions> dataList = pageUtil.getPageList();
//开始拼接json数据
JSONObject outer = new JSONObject();
outer.put("id", 1);
outer.put("text", "功能列表");
outer.put("state", "open");
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Functions functions:dataList)
{
JSONObject item = new JSONObject();
item.put("id", functions.getId());
item.put("text", functions.getName());
//勾选判断1
Boolean flag = false;
try
{
flag = userBusinessService.checkIsUserBusinessExist("Type",model.getUBType(),"KeyId",model.getUBKeyId(),"Value","["+functions.getId().toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>设置角色对应的功能：类型" + model.getUBType() + " KeyId为： " + model.getUBKeyId() + " 存在异常！");
}
if (flag==true){item.put("checked", true);}
//结束
pageUtil.setAdvSearch(getCondition_RoleFunctions(functions.getNumber()));
functionsService.find(pageUtil);
List<Functions> dataList1 = pageUtil.getPageList();
JSONArray dataArray1 = new JSONArray();
if(null != dataList1)
{
for(Functions functions1:dataList1)
{
item.put("state", "open"); //如果不为空，节点不展开
JSONObject item1 = new JSONObject();
item1.put("id", functions1.getId());
item1.put("text", functions1.getName());
//勾选判断2
//Boolean flag = false;
try
{
flag = userBusinessService.checkIsUserBusinessExist("Type",model.getUBType(),"KeyId",model.getUBKeyId(),"Value","["+functions1.getId().toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>设置角色对应的功能：类型" + model.getUBType() + " KeyId为： " + model.getUBKeyId() + " 存在异常！");
}
if (flag==true){item1.put("checked", true);}
//结束
pageUtil.setAdvSearch(getCondition_RoleFunctions(functions1.getNumber()));
functionsService.find(pageUtil);
List<Functions> dataList2 = pageUtil.getPageList();
JSONArray dataArray2 = new JSONArray();
if(null != dataList2)
{
for(Functions functions2:dataList2)
{
item1.put("state", "closed"); //如果不为空，节点不展开
JSONObject item2 = new JSONObject();
item2.put("id", functions2.getId());
item2.put("text", functions2.getName());
//勾选判断3
//Boolean flag = false;
try
{
flag = userBusinessService.checkIsUserBusinessExist("Type",model.getUBType(),"KeyId",model.getUBKeyId(),"Value","["+functions2.getId().toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>设置角色对应的功能：类型" + model.getUBType() + " KeyId为： " + model.getUBKeyId() + " 存在异常！");
}
if (flag==true){item2.put("checked", true);}
//结束
pageUtil.setAdvSearch(getCondition_RoleFunctions(functions2.getNumber()));
functionsService.find(pageUtil);
List<Functions> dataList3 = pageUtil.getPageList();
JSONArray dataArray3 = new JSONArray();
if(null != dataList3)
{
for(Functions functions3:dataList3)
{
item2.put("state", "closed"); //如果不为空，节点不展开
JSONObject item3 = new JSONObject();
item3.put("id", functions3.getId());
item3.put("text", functions3.getName());
//勾选判断4
//Boolean flag = false;
try
{
flag = userBusinessService.checkIsUserBusinessExist("Type",model.getUBType(),"KeyId",model.getUBKeyId(),"Value","["+functions3.getId().toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>设置角色对应的功能：类型" + model.getUBType() + " KeyId为： " + model.getUBKeyId() + " 存在异常！");
}
if (flag==true){item3.put("checked", true);}
//结束
dataArray3.add(item3);
item2.put("children", dataArray3);
}
}
dataArray2.add(item2);
item1.put("children", dataArray2);
}
}
dataArray1.add(item1);
item.put("children", dataArray1);
}
}
dataArray.add(item);
}
outer.put("children", dataArray);
}
//回写查询结果
toClient("["+outer.toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找应用异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询应用结果异常", e);
}
}
/**
* 页面显示菜单
* @return
*/
public void findMenu()
{
try
{
String fc=model.getHasFunctions(); //当前用户所拥有的功能列表，格式如：[1][2][5]
PageUtil<Functions> pageUtil = new PageUtil<Functions>();
pageUtil.setPageSize(200);
pageUtil.setAdvSearch(getCondition_RoleFunctions(model.getPNumber()));
functionsService.find(pageUtil);
List<Functions> dataList = pageUtil.getPageList();
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Functions functions:dataList)
{
JSONObject item = new JSONObject();
item.put("id", functions.getId());
pageUtil.setAdvSearch(getCondition_RoleFunctions(functions.getNumber()));
functionsService.find(pageUtil);
List<Functions> dataList1 = pageUtil.getPageList();
JSONArray dataArray1 = new JSONArray();
if(dataList1.size()!=0)
{
item.put("text", functions.getName()); //是目录就没链接
for(Functions functions1:dataList1)
{
item.put("state", "open"); //如果不为空，节点展开
JSONObject item1 = new JSONObject();
pageUtil.setAdvSearch(getCondition_RoleFunctions(functions1.getNumber()));
functionsService.find(pageUtil);
List<Functions> dataList2 = pageUtil.getPageList();
if(fc.indexOf("["+functions1.getId().toString()+"]")!=-1||dataList2.size()!=0)
{
item1.put("id", functions1.getId());
JSONArray dataArray2 = new JSONArray();
if(dataList2.size()!=0)
{
item1.put("text", functions1.getName());//是目录就没链接
for(Functions functions2:dataList2)
{
item1.put("state", "closed"); //如果不为空，节点不展开
JSONObject item2 = new JSONObject();
pageUtil.setAdvSearch(getCondition_RoleFunctions(functions2.getNumber()));
functionsService.find(pageUtil);
List<Functions> dataList3 = pageUtil.getPageList();
if(fc.indexOf("["+functions2.getId().toString()+"]")!=-1||dataList3.size()!=0)
{
item2.put("id", functions2.getId());
JSONArray dataArray3 = new JSONArray();
if(dataList3.size()!=0)
{
item2.put("text", functions2.getName());//是目录就没链接
for(Functions functions3:dataList3)
{
item2.put("state", "closed"); //如果不为空，节点不展开
JSONObject item3 = new JSONObject();
item3.put("id", functions3.getId());
item3.put("text", functions3.getName());
//
dataArray3.add(item3);
item2.put("children", dataArray3);
}
}
else
{
//不是目录，有链接
item2.put("text", "<a onclick=\"NewTab('"+functions2.getName()+"','"+functions2.getURL()+"')\">"+functions2.getName()+"</a>");
}
dataArray2.add(item2);
item1.put("children", dataArray2);
}
}
}
else
{
//不是目录，有链接
item1.put("text", "<a onclick=\"NewTab('"+functions1.getName()+"','"+functions1.getURL()+"')\">"+functions1.getName()+"</a>");
}
dataArray1.add(item1);
item.put("children", dataArray1);
}
}
}
else
{
//不是目录，有链接
item.put("text", "<a onclick=\"NewTab('"+functions.getName()+"','"+functions.getURL()+"')\">"+functions.getName()+"</a>");
}
dataArray.add(item);
}
}
//回写查询结果
toClient(dataArray.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找应用异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询应用结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("Name_s_like", model.getName());
condition.put("Type_s_eq", model.getType());
condition.put("Sort_s_order", "asc");
return condition;
}
/**
* 拼接搜索条件-角色对应功能
* @return
*/
private Map<String,Object> getCondition_RoleFunctions(String num)
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("Enabled_n_eq", 1);
condition.put("PNumber_s_eq", num);
condition.put("Sort_s_order", "asc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public FunctionsModel getModel()
{
return model;
}
public void setFunctionsService(FunctionsIService functionsService)
{
this.functionsService = functionsService;
}
public void setUserBusinessService(UserBusinessIService userBusinessService) {
this.userBusinessService = userBusinessService;
}
}
src/com/jsh/action/basic/InOutItemAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.Logdetails;
import com.jsh.model.po.InOutItem;
import com.jsh.model.vo.basic.InOutItemModel;
import com.jsh.service.basic.InOutItemIService;
import com.jsh.util.PageUtil;
/**
* 收支项目
* @author ji*sheng*hua qq 7.5.2.7.1.8.9.2.0
*/
@SuppressWarnings("serial")
public class InOutItemAction extends BaseAction<InOutItemModel>
{
private InOutItemIService inOutItemService;
private InOutItemModel model = new InOutItemModel();
/**
* 增加收支项目
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加收支项目方法===================");
Boolean flag = false;
try
{
InOutItem inOutItem = new InOutItem();
inOutItem.setName(model.getName());
inOutItem.setType(model.getType());
inOutItem.setRemark(model.getRemark());
inOutItemService.create(inOutItem);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加收支项目异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加收支项目回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加收支项目", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加收支项目名称为 "+ model.getName() + " " + tipMsg + "！", "增加收支项目" + tipMsg));
Log.infoFileSync("==================结束调用增加收支项目方法===================");
}
/**
* 删除收支项目
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除收支项目信息方法delete()================");
try
{
inOutItemService.delete(model.getInOutItemID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getInOutItemID() + " 的收支项目异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除收支项目", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除收支项目ID为 "+ model.getInOutItemID() + ",名称为 " + model.getName() + tipMsg + "！", "删除收支项目" + tipMsg));
Log.infoFileSync("====================结束调用删除收支项目信息方法delete()================");
return SUCCESS;
}
/**
* 更新收支项目
* @return
*/
public void update()
{
Boolean flag = false;
try
{
InOutItem inOutItem = inOutItemService.get(model.getInOutItemID());
inOutItem.setName(model.getName());
inOutItem.setType(model.getType());
inOutItem.setRemark(model.getRemark());
inOutItemService.update(inOutItem);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改收支项目ID为 ： " + model.getInOutItemID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改收支项目回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新收支项目", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新收支项目ID为 "+ model.getInOutItemID() + " " + tipMsg + "！", "更新收支项目" + tipMsg));
}
/**
* 批量删除指定ID收支项目
* @return
*/
public String batchDelete()
{
try
{
inOutItemService.batchDelete(model.getInOutItemIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除收支项目ID为：" + model.getInOutItemIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除收支项目", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除收支项目ID为 "+ model.getInOutItemIDs() + " " + tipMsg + "！", "批量删除收支项目" + tipMsg));
return SUCCESS;
}
/**
* 检查输入名称是否存在
*/
public void checkIsNameExist()
{
Boolean flag = false;
try
{
flag = inOutItemService.checkIsNameExist("name",model.getName(),"id", model.getInOutItemID());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查收支项目名称为：" + model.getName() + " ID为： " + model.getInOutItemID() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查收支项目名称为：" + model.getName() + " ID为： " + model.getInOutItemID() + " 是否存在异常！",e);
}
}
}
/**
* 查找收支项目信息
* @return
*/
public void findBy()
{
try
{
PageUtil<InOutItem> pageUtil = new PageUtil<InOutItem>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
inOutItemService.find(pageUtil);
List<InOutItem> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(InOutItem inOutItem:dataList)
{
JSONObject item = new JSONObject();
item.put("id", inOutItem.getId());
//收支项目名称
item.put("name", inOutItem.getName());
item.put("type", inOutItem.getType());
item.put("remark", inOutItem.getRemark());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找收支项目信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询收支项目信息结果异常", e);
}
}
/**
* 查找收支项目信息-下拉框
* @return
*/
public void findBySelect()
{
try
{
PageUtil<InOutItem> pageUtil = new PageUtil<InOutItem>();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
pageUtil.setAdvSearch(getCondition_select());
inOutItemService.find(pageUtil);
List<InOutItem> dataList = pageUtil.getPageList();
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(InOutItem inOutItem:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", inOutItem.getId());
//收支项目名称
item.put("InOutItemName", inOutItem.getName());
dataArray.add(item);
}
}
//回写查询结果
toClient(dataArray.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找收支项目信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询收支项目信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("name_s_like", model.getName());
condition.put("remark_s_like", model.getRemark());
condition.put("id_s_order", "desc");
return condition;
}
/**
* 拼接搜索条件-下拉框-收支项目
* @return
*/
private Map<String,Object> getCondition_select()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
if(model.getType().equals("in")) {
condition.put("type_s_eq", "收入");
}
else if(model.getType().equals("out")) {
condition.put("type_s_eq", "支出");
}
condition.put("id_s_order", "desc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public InOutItemModel getModel()
{
return model;
}
public void setInOutItemService(InOutItemIService inOutItemService)
{
this.inOutItemService = inOutItemService;
}
}
src/com/jsh/action/basic/LogAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.Logdetails;
import com.jsh.model.vo.basic.LogModel;
import com.jsh.service.basic.UserIService;
import com.jsh.util.PageUtil;
import com.jsh.util.Tools;
/*
*日志管理
* @author jishenghua qq:7-5-2-7-1-8-9-2-0
*/
@SuppressWarnings("serial")
public class LogAction extends BaseAction<LogModel>
{
private LogModel model = new LogModel();
private UserIService userService;
@SuppressWarnings({ "rawtypes", "unchecked" })
public String getBasicData()
{
Map<String,List> mapData = model.getShowModel().getMap();
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try
{
Map<String,Object> condition = pageUtil.getAdvSearch();
condition.clear();
condition.put("ismanager_n_eq", 0);
userService.find(pageUtil);
mapData.put("userList", pageUtil.getPageList());
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>查找系统基础数据信息异常", e);
model.getShowModel().setMsgTip("exceptoin");
}
return SUCCESS;
}
/**
* 删除日志
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除日志信息方法delete()================");
try
{
logService.delete(model.getLogID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getLogID() + " 的日志异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除日志", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除日志ID为 "+ model.getLogID() + " " + tipMsg + "！", "删除日志" + tipMsg));
Log.infoFileSync("====================结束调用删除日志信息方法delete()================");
return SUCCESS;
}
/**
* 批量删除指定ID日志
* @return
*/
public String batchDelete()
{
try
{
logService.batchDelete(model.getLogIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除日志ID为：" + model.getLogIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除日志", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除日志ID为 "+ model.getLogIDs() + " " + tipMsg + "！", "批量删除日志" + tipMsg));
return SUCCESS;
}
/**
* 查找日志信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Logdetails> pageUtil = new PageUtil<Logdetails>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
logService.find(pageUtil);
List<Logdetails> dataList = pageUtil.getPageList();
//开始拼接json数据
// {"total":28,"rows":[
// {"productid":"AV-CB-01","attr1":"Adult Male","itemid":"EST-18"}
// ]}
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Logdetails log:dataList)
{
JSONObject item = new JSONObject();
item.put("id", log.getId());
item.put("clientIP", log.getClientIp());
item.put("details", log.getContentdetails());
item.put("createTime", Tools.getCenternTime(log.getCreatetime()));
item.put("operation", log.getOperation());
item.put("remark", log.getRemark());
item.put("status", log.getStatus() == 0 ?"成功":"失败");
item.put("statusShort", log.getStatus());
item.put("username", log.getUser()==null?"":log.getUser().getUsername());
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找日志信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询日志信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("user.id_n_eq", model.getUsernameID());
condition.put("createtime_s_gteq", model.getBeginTime());
condition.put("createtime_s_lteq", model.getEndTime());
condition.put("operation_s_like", model.getOperation());
condition.put("clientIp_s_like", model.getClientIp());
condition.put("status_n_eq", model.getStatus());
condition.put("contentdetails_s_like", model.getContentdetails());
condition.put("remark_s_like", model.getRemark());
condition.put("createtime_s_order", "desc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
public void setUserService(UserIService userService)
{
this.userService = userService;
}
@Override
public LogModel getModel()
{
return model;
}
}
src/com/jsh/action/basic/RoleAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.util.JshException;
import com.jsh.model.po.App;
import com.jsh.model.po.Role;
import com.jsh.model.po.Logdetails;
import com.jsh.model.vo.basic.RoleModel;
import com.jsh.service.basic.RoleIService;
import com.jsh.service.basic.UserBusinessIService;
import com.jsh.util.PageUtil;
/*
* 角色管理
* @author jishenghua qq:7-5-2-7-1-8-9-2-0
*/
@SuppressWarnings("serial")
public class RoleAction extends BaseAction<RoleModel>
{
private RoleIService roleService;
private UserBusinessIService userBusinessService;
private RoleModel model = new RoleModel();
/**
* 增加角色
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加角色信息方法create()===================");
Boolean flag = false;
try
{
Role role = new Role();
role.setName(model.getName());
roleService.create(role);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加角色信息异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加角色信息回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加角色", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加角色名称为 "+ model.getName() + " " + tipMsg + "！", "增加角色" + tipMsg));
Log.infoFileSync("==================结束调用增加角色方法create()===================");
}
/**
* 删除角色
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除角色信息方法delete()================");
try
{
roleService.delete(model.getRoleID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getRoleID() + " 的角色异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除角色", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除角色ID为 "+ model.getRoleID() + " " + tipMsg + "！", "删除角色" + tipMsg));
Log.infoFileSync("====================结束调用删除角色信息方法delete()================");
return SUCCESS;
}
/**
* 更新角色
* @return
*/
public void update()
{
Boolean flag = false;
try
{
Role role = roleService.get(model.getRoleID());
role.setName(model.getName());
roleService.update(role);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改角色ID为 ： " + model.getRoleID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改角色回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新角色", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新角色ID为 "+ model.getRoleID() + " " + tipMsg + "！", "更新角色" + tipMsg));
}
/**
* 批量删除指定ID角色
* @return
*/
public String batchDelete()
{
try
{
roleService.batchDelete(model.getRoleIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除角色ID为：" + model.getRoleIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除角色", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除角色ID为 "+ model.getRoleIDs() + " " + tipMsg + "！", "批量删除角色" + tipMsg));
return SUCCESS;
}
/**
* 检查输入名称是否存在
*/
public void checkIsNameExist()
{
Boolean flag = false;
try
{
flag = roleService.checkIsNameExist("name",model.getName(),"Id", model.getRoleID());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查角色名称为：" + model.getName() + " ID为： " + model.getRoleID() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查角色名称为：" + model.getName() + " ID为： " + model.getRoleID() + " 是否存在异常！",e);
}
}
}
/**
* 查找角色信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Role> pageUtil = new PageUtil<Role>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
roleService.find(pageUtil);
List<Role> dataList = pageUtil.getPageList();
//开始拼接json数据
// {"total":28,"rows":[
// {"productid":"AV-CB-01","attr1":"Adult Male","itemid":"EST-18"}
// ]}
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Role role:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", role.getId());
//供应商名称
item.put("Name", role.getName());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找角色信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询角色信息结果异常", e);
}
}
/**
* 用户对应角色显示
* @return
*/
public void findUserRole()
{
try
{
PageUtil<Role> pageUtil = new PageUtil<Role>();
pageUtil.setPageSize(100);
//pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition_UserRole());
roleService.find(pageUtil);
List<Role> dataList = pageUtil.getPageList();
//开始拼接json数据
JSONObject outer = new JSONObject();
outer.put("id", 1);
outer.put("text", "角色列表");
outer.put("state", "open");
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Role role:dataList)
{
JSONObject item = new JSONObject();
item.put("id", role.getId());
item.put("text", role.getName());
//勾选判断1
Boolean flag = false;
try
{
flag = userBusinessService.checkIsUserBusinessExist("Type",model.getUBType(),"KeyId",model.getUBKeyId(),"Value","["+role.getId().toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>设置用户对应的角色：类型" + model.getUBType() + " KeyId为： " + model.getUBKeyId() + " 存在异常！");
}
if (flag==true){item.put("checked", true);}
//结束
dataArray.add(item);
}
}
outer.put("children", dataArray);
//回写查询结果
toClient("["+outer.toString()+"]");
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找角色异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询角色结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("Name_s_like", model.getName());
condition.put("Id_s_order", "asc");
return condition;
}
/**
* 拼接搜索条件-用户对应角色
* @return
*/
private Map<String,Object> getCondition_UserRole()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("Id_s_order", "asc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public RoleModel getModel()
{
return model;
}
public void setRoleService(RoleIService roleService)
{
this.roleService = roleService;
}
public void setUserBusinessService(UserBusinessIService userBusinessService) {
this.userBusinessService = userBusinessService;
}
}
src/com/jsh/action/basic/SupplierAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.Logdetails;
import com.jsh.model.po.Supplier;
import com.jsh.model.vo.basic.SupplierModel;
import com.jsh.service.basic.SupplierIService;
import com.jsh.util.PageUtil;
/*
* 单位管理
* @author jishenghua qq:752718920
*/
@SuppressWarnings("serial")
public class SupplierAction extends BaseAction<SupplierModel>
{
private SupplierIService supplierService;
private SupplierModel model = new SupplierModel();
/**
* 增加供应商
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加供应商方法===================");
Boolean flag = false;
try
{
Supplier supplier = new Supplier();
supplier.setContacts(model.getContacts());
supplier.setType(model.getType());
supplier.setDescription(model.getDescription());
supplier.setEmail(model.getEmail());
supplier.setBeginNeedGet(model.getBeginNeedGet());
supplier.setBeginNeedPay(model.getBeginNeedPay());
supplier.setIsystem((short)1);
supplier.setPhonenum(model.getPhonenum());
supplier.setSupplier(model.getSupplier());
supplier.setEnabled(model.getEnabled());
supplierService.create(supplier);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加供应商异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加供应商回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加供应商", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加供应商名称为 "+ model.getSupplier() + " " + tipMsg + "！", "增加供应商" + tipMsg));
Log.infoFileSync("==================结束调用增加供应商方法===================");
}
/**
* 删除供应商
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除供应商信息方法delete()================");
try
{
supplierService.delete(model.getSupplierID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getSupplierID() + " 的供应商异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除供应商", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除供应商ID为 "+ model.getSupplierID() + ",名称为 " + model.getSupplier() + tipMsg + "！", "删除供应商" + tipMsg));
Log.infoFileSync("====================结束调用删除供应商信息方法delete()================");
return SUCCESS;
}
/**
* 更新供应商
* @return
*/
public void update()
{
Boolean flag = false;
try
{
Supplier supplier = supplierService.get(model.getSupplierID());
supplier.setContacts(model.getContacts());
supplier.setType(model.getType());
supplier.setDescription(model.getDescription());
supplier.setEmail(model.getEmail());
supplier.setBeginNeedGet(model.getBeginNeedGet());
supplier.setBeginNeedPay(model.getBeginNeedPay());
supplier.setIsystem((short)1);
supplier.setPhonenum(model.getPhonenum());
supplier.setSupplier(model.getSupplier());
supplier.setEnabled(model.getEnabled());
supplierService.update(supplier);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改供应商ID为 ： " + model.getSupplierID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改供应商回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新供应商", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新供应商ID为 "+ model.getSupplierID() + " " + tipMsg + "！", "更新供应商" + tipMsg));
}
/**
* 批量删除指定ID供应商
* @return
*/
public String batchDelete()
{
try
{
supplierService.batchDelete(model.getSupplierIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除供应商ID为：" + model.getSupplierIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除供应商", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除供应商ID为 "+ model.getSupplierIDs() + " " + tipMsg + "！", "批量删除供应商" + tipMsg));
return SUCCESS;
}
/**
* 检查输入名称是否存在
*/
public void checkIsNameExist()
{
Boolean flag = false;
try
{
flag = supplierService.checkIsNameExist("supplier",model.getSupplier(),"id", model.getSupplierID());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查供应商名称为：" + model.getSupplier() + " ID为： " + model.getSupplierID() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查供应商名称为：" + model.getSupplier() + " ID为： " + model.getSupplierID() + " 是否存在异常！",e);
}
}
}
/**
* 查找供应商信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Supplier> pageUtil = new PageUtil<Supplier>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
supplierService.find(pageUtil);
List<Supplier> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Supplier supplier:dataList)
{
JSONObject item = new JSONObject();
item.put("id", supplier.getId());
//供应商名称
item.put("supplier", supplier.getSupplier());
item.put("type", supplier.getType());
item.put("contacts",supplier.getContacts());
item.put("phonenum", supplier.getPhonenum());
item.put("email", supplier.getEmail());
item.put("BeginNeedGet",supplier.getBeginNeedGet());
item.put("BeginNeedPay",supplier.getBeginNeedPay());
item.put("AllNeedGet",supplier.getAllNeedGet());
item.put("AllNeedPay",supplier.getAllNeedPay());
item.put("isystem", supplier.getIsystem() == (short)0?"是":"否");
item.put("description", supplier.getDescription());
item.put("enabled", supplier.getEnabled());
item.put("op", supplier.getIsystem());
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找供应商信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询供应商信息结果异常", e);
}
}
/**
* 查找供应商信息-下拉框
* @return
*/
public void findBySelect_sup()
{
try
{
PageUtil<Supplier> pageUtil = new PageUtil<Supplier>();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
pageUtil.setAdvSearch(getCondition_Select_sup());
supplierService.find(pageUtil);
List<Supplier> dataList = pageUtil.getPageList();
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Supplier supplier:dataList)
{
JSONObject item = new JSONObject();
item.put("id", supplier.getId());
//供应商名称
item.put("supplier", supplier.getSupplier());
dataArray.add(item);
}
}
//回写查询结果
toClient(dataArray.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找供应商信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询供应商信息结果异常", e);
}
}
/**
* 查找客户信息-下拉框
* @return
*/
public void findBySelect_cus()
{
try
{
PageUtil<Supplier> pageUtil = new PageUtil<Supplier>();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
pageUtil.setAdvSearch(getCondition_Select_cus());
supplierService.find(pageUtil);
List<Supplier> dataList = pageUtil.getPageList();
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Supplier supplier:dataList)
{
JSONObject item = new JSONObject();
item.put("id", supplier.getId());
//客户名称
item.put("supplier", supplier.getSupplier());
dataArray.add(item);
}
}
//回写查询结果
toClient(dataArray.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找客户信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询客户信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("supplier_s_like", model.getSupplier());
condition.put("type_s_like", model.getType());
condition.put("contacts_s_like", model.getContacts());
condition.put("phonenum_s_like", model.getPhonenum());
condition.put("email_s_like", model.getEmail());
condition.put("description_s_like", model.getDescription());
condition.put("id_s_order", "desc");
return condition;
}
/**
* 拼接搜索条件-下拉框-供应商
* @return
*/
private Map<String,Object> getCondition_Select_sup()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("type_s_like", "供应商");
condition.put("id_s_order", "desc");
return condition;
}
/**
* 拼接搜索条件-下拉框-客户
* @return
*/
private Map<String,Object> getCondition_Select_cus()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("type_s_like", "客户");
condition.put("id_s_order", "desc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public SupplierModel getModel()
{
return model;
}
public void setSupplierService(SupplierIService supplierService)
{
this.supplierService = supplierService;
}
}
src/com/jsh/action/basic/UserAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.util.ExceptionCodeConstants;
import com.jsh.model.po.Basicuser;
import com.jsh.model.po.Logdetails;
import com.jsh.model.vo.basic.UserModel;
import com.jsh.service.basic.UserIService;
import com.jsh.util.PageUtil;
import com.jsh.util.Tools;
/*
* 用户管理
* @author jishenghua qq:752718920
*/
@SuppressWarnings("serial")
public class UserAction extends BaseAction<UserModel>
{
private UserModel model = new UserModel();
private UserIService userService;
/**
* 需要判断用户状态，用户名密码错误不能登录 ，黑名单用户不能登录，如果已经登录过，不再进行处理，直接进入管理页面
* @return
*/
public String login()
{
Log.infoFileSync("============用户登录 login 方法调用开始==============");
String username = model.getLoginame().trim();
String password = model.getPassword().trim();
//因密码用MD5加密，需要对密码进行转化
try
{
password = Tools.md5Encryp(password);
System.out.println(password);
}
catch (NoSuchAlgorithmException e)
{
e.printStackTrace();
Log.errorFileSync(">>>>>>>>>>>>>>转化MD5字符串错误 ：" + e.getMessage(), e);
}
//判断用户是否已经登录过，登录过不再处理
Basicuser sessionUser = (Basicuser)getSession().get("user");
if(null != sessionUser && username.equalsIgnoreCase(sessionUser.getLoginame())
&& sessionUser.getPassword().equals(password))
{
Log.infoFileSync("====用户 "+ username + "已经登录过, login 方法调用结束====");
model.getShowModel().setMsgTip("user already login");
/*return "login";*/
}
//获取用户状态
int userStatus = -1;
try
{
userStatus = userService.validateUser(username, password);
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>用户 " + username + " 登录 login 方法 访问服务层异常====",e);
model.getShowModel().setMsgTip("access service exception");
}
switch (userStatus)
{
case ExceptionCodeConstants.UserExceptionCode.USER_NOT_EXIST:
model.getShowModel().setMsgTip("user is not exist");
break;
case ExceptionCodeConstants.UserExceptionCode.USER_PASSWORD_ERROR:
model.getShowModel().setMsgTip("user password error");
break;
case ExceptionCodeConstants.UserExceptionCode.BLACK_USER:
model.getShowModel().setMsgTip("user is black");
break;
case ExceptionCodeConstants.UserExceptionCode.USER_ACCESS_EXCEPTION:
model.getShowModel().setMsgTip("access service error");
break;
default:
try
{
//验证通过 ，可以登录，放入session，记录登录日志
Basicuser user = userService.getUser(username);
logService.create(new Logdetails(user, "登录系统", model.getClientIp(),
new Timestamp(System.currentTimeMillis()), (short)0,"管理用户：" + username + " 登录系统",username + " 登录系统"));
model.getShowModel().setMsgTip("user can login");
getSession().put("user", user);
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>查询用户名为:" + username + " ，用户信息异常", e);
}
break;
}
/*if(ExceptionCodeConstants.UserExceptionCode.USER_CONDITION_FIT == userStatus)
return "login";*/
Log.infoFileSync("===============用户登录 login 方法调用结束===============");
return SUCCESS;
}
/**
* 用户退出登录
* @return
*/
public String logout()
{
logService.create(new Logdetails(getUser(), "退出系统", model.getClientIp(),
new Timestamp(System.currentTimeMillis()), (short)0,
"管理用户：" + getUser().getLoginame() + " 退出系统",getUser().getLoginame() + " 退出系统"));
getSession().remove("user");
return SUCCESS;
}
/**
* 增加用户
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加用户方法===================");
Boolean flag = false;
try
{
Basicuser user = new Basicuser();
user.setDepartment(model.getDepartment());
user.setDescription(model.getDescription());
user.setEmail(model.getEmail());
// user.setIsmanager(model.getIsmanager());
user.setIsystem((short)1);
user.setIsmanager((short)1);
user.setLoginame(model.getLoginame());
String password ="123456";
//因密码用MD5加密，需要对密码进行转化
try
{
password=Tools.md5Encryp(password);
}
catch (NoSuchAlgorithmException e)
{
e.printStackTrace();
Log.errorFileSync(">>>>>>>>>>>>>>转化MD5字符串错误 ：" + e.getMessage(), e);
}
user.setPassword(password);
user.setPhonenum(model.getPhonenum());
user.setPosition(model.getPosition());
user.setUsername(model.getUsername());
userService.create(user);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加用户异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加用户回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加用户", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加用户名称为 "+ model.getUsername() + " " + tipMsg + "！", "增加用户" + tipMsg));
Log.infoFileSync("==================结束调用增加用户方法===================");
}
/**
* 删除用户
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除用户信息方法delete()================");
try
{
userService.delete(model.getUserID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getUserID() + " 的用户异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除用户", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除用户ID为 "+ model.getUserID() + " " + tipMsg + "！", "删除用户" + tipMsg));
Log.infoFileSync("====================结束调用删除用户信息方法delete()================");
return SUCCESS;
}
/**
* 更新用户
* @return
*/
public void update()
{
Boolean flag = false;
try
{
Basicuser user = userService.get(model.getUserID());
user.setDepartment(model.getDepartment());
user.setDescription(model.getDescription());
user.setEmail(model.getEmail());
//user.setIsmanager(model.getIsmanager());
user.setLoginame(model.getLoginame());
//user.setPassword(model.getPassword());
user.setPhonenum(model.getPhonenum());
user.setPosition(model.getPosition());
user.setUsername(model.getUsername());
userService.update(user);
//看是否需要更新seesion中user
if(getUser().getId() == model.getUserID())
{
getSession().put("user", user);
}
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改用户ID为 ： " + model.getUserID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改用户回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新用户", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新用户ID为 "+ model.getUserID() + " " + tipMsg + "！", "更新用户" + tipMsg));
}
/**
* 修改密码
*/
public void updatePwd()
{
Integer flag = 0;
try
{
Basicuser user = getUser();
String orgPassword = Tools.md5Encryp(model.getOrgpwd());
String md5Pwd = Tools.md5Encryp(model.getPassword());
//必须和原始密码一致才可以更新密码
if(orgPassword.equalsIgnoreCase(user.getPassword()))
{
user.setPassword(md5Pwd);
userService.update(user);
//看是否需要更新seesion中user
// if(getUser().getId() == model.getUserID())
// {
// getSession().put("user", user);
// }
flag = 1;
tipMsg = "成功";
tipType = 0;
}
else
{
flag = 2;
tipMsg = "失败";
tipType = 1;
}
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改用户ID为 ： " + model.getUserID() + "密码信息失败", e);
flag = 3;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改用户密码回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新用户", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新用户ID为 "+ model.getUserID() + "密码信息 " + tipMsg + "！", "更新用户" + tipMsg));
}
/**
* 批量删除指定ID用户
* @return
*/
public String batchDelete()
{
try
{
userService.batchDelete(model.getUserIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除用户ID为：" + model.getUserIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除用户", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除用户ID为 "+ model.getUserIDs() + " " + tipMsg + "！", "批量删除用户" + tipMsg));
return SUCCESS;
}
/**
* 检查输入名称是否存在
*/
public void checkIsNameExist()
{
Boolean flag = false;
String fieldName = "";
String fieldValue = "";
try
{
if(0 == model.getCheckFlag())
{
fieldName = "username";
fieldValue = model.getUsername();
}
else
{
fieldName = "loginame";
fieldValue = model.getLoginame();
}
flag = userService.checkIsNameExist(fieldName,fieldValue, model.getUserID());
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查用户名称为：" + fieldValue + " ID为： " + model.getUserID() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查用户名称为：" + fieldValue + " ID为： " + model.getUserID() + " 是否存在异常！",e);
}
}
}
/**
* 查找用户信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Basicuser> pageUtil = new PageUtil<Basicuser>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
userService.find(pageUtil);
List<Basicuser> dataList = pageUtil.getPageList();
//开始拼接json数据
// {"total":28,"rows":[
// {"productid":"AV-CB-01","attr1":"Adult Male","itemid":"EST-18"}
// ]}
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Basicuser user:dataList)
{
JSONObject item = new JSONObject();
item.put("id", user.getId());
item.put("username", user.getUsername());
item.put("loginame", Tools.dealNullStr(user.getLoginame()));
item.put("password", Tools.dealNullStr(user.getPassword()));
item.put("position", Tools.dealNullStr(user.getPosition()));
item.put("department", Tools.dealNullStr(user.getDepartment()));
item.put("email", Tools.dealNullStr(user.getEmail()));
item.put("phonenum", Tools.dealNullStr(user.getPhonenum()));
item.put("ismanager", user.getIsmanager()== (short)0?"是":"否");
item.put("isystem",user.getIsystem() == (short)0?"是":"否");
item.put("status", user.getStatus());
item.put("description", Tools.dealNullStr(user.getDescription()));
item.put("remark",user.getRemark());
item.put("op", user.getIsystem());
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找用户信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询用户信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return 拼接后的条件
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("username_s_like", model.getUsername());
condition.put("loginame_s_like", model.getLoginame());
condition.put("id_s_order", "asc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public UserModel getModel()
{
return model;
}
public void setUserService(UserIService userService)
{
this.userService = userService;
}
}
src/com/jsh/action/basic/UserBusinessAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.basic;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.UserBusiness;
import com.jsh.model.po.Logdetails;
import com.jsh.model.vo.basic.UserBusinessModel;
import com.jsh.service.basic.UserBusinessIService;
import com.jsh.util.PageUtil;
/*
* 权限关系管理
* @author jishenghua qq:752718920
*/
@SuppressWarnings("serial")
public class UserBusinessAction extends BaseAction<UserBusinessModel>
{
private UserBusinessIService userBusinessService;
private UserBusinessModel model = new UserBusinessModel();
@SuppressWarnings({ "rawtypes", "unchecked" })
public String getBasicData()
{
Map<String,List> mapData = model.getShowModel().getMap();
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try
{
Map<String,Object> condition = pageUtil.getAdvSearch();
condition.put("KeyId_s_eq", model.getKeyId());
condition.put("Type_s_eq", model.getType());
userBusinessService.find(pageUtil);
mapData.put("userBusinessList", pageUtil.getPageList());
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>查找UserBusiness信息异常", e);
model.getShowModel().setMsgTip("exceptoin");
}
return SUCCESS;
}
/*
* 测试hql语句的写法
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public String getceshi()
{
Map<String,List> mapData = model.getShowModel().getMap();
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try
{
Map<String,Object> condition = pageUtil.getAdvSearch();
condition.put("Type_s_eq", model.getType());
userBusinessService.find(pageUtil,"ceshi");
mapData.put("userBusinessList", pageUtil.getPageList());
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>查找UserBusiness信息异常", e);
model.getShowModel().setMsgTip("exceptoin");
}
return SUCCESS;
}
/**
* 增加UserBusiness
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加UserBusiness信息方法create()===================");
Boolean flag = false;
try
{
UserBusiness userBusiness = new UserBusiness();
userBusiness.setType(model.getType());
userBusiness.setKeyId(model.getKeyId());
userBusiness.setValue(model.getValue());
userBusinessService.create(userBusiness);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加UserBusiness信息异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加UserBusiness信息回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加UserBusiness", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加UserBusiness为 "+ model.getType() + " " + tipMsg + "！", "增加UserBusiness" + tipMsg));
Log.infoFileSync("==================结束调用增加UserBusiness方法create()===================");
}
/**
* 更新UserBusiness
* @return
*/
public void update()
{
Boolean flag = false;
Long id=0l;
try
{
PageUtil<UserBusiness> pageUtil = new PageUtil<UserBusiness>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition_RoleAPP());
userBusinessService.find(pageUtil);
List<UserBusiness> dataList = pageUtil.getPageList();
if(null != dataList)
{
for(UserBusiness userBusiness:dataList)
{
id=userBusiness.getId();
}
UserBusiness userBusiness = userBusinessService.get(id);
userBusiness.setType(model.getType());
userBusiness.setKeyId(model.getKeyId());
userBusiness.setValue(model.getValue());
userBusinessService.update(userBusiness);
}
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改UserBusiness的ID为 ： " + id + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改UserBusiness回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新UserBusiness", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新UserBusiness的ID为 "+ id + " " + tipMsg + "！", "更新UserBusiness" + tipMsg));
}
/**
* 拼接搜索条件-RoleAPP
* @return
*/
private Map<String,Object> getCondition_RoleAPP()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("Type_s_eq", model.getType());
condition.put("KeyId_s_eq", model.getKeyId());
return condition;
}
/**
* 检查角色对应应用/功能是否存在
*/
public void checkIsValueExist()
{
Boolean flag = false;
try
{
flag = userBusinessService.checkIsValueExist("Type",model.getType(),"KeyId", model.getKeyId());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>检查角色对应应用/功能的类型为：" + model.getType() + " KeyId为： " + model.getKeyId() + " 是否存在异常！");
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>回写检查角色对应应用/功能的类型为：" + model.getType() + " KeyId为： " + model.getKeyId() + " 是否存在异常！",e);
}
}
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public UserBusinessModel getModel()
{
return model;
}
public void setUserBusinessService(UserBusinessIService userBusinessService)
{
this.userBusinessService = userBusinessService;
}
}
src/com/jsh/action/materials/AccountHeadAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.materials;
import java.io.IOException;
import java.sql.Timestamp;
import java.text.ParseException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.Account;
import com.jsh.model.po.AccountHead;
import com.jsh.model.po.Logdetails;
import com.jsh.model.po.Person;
import com.jsh.model.po.Supplier;
import com.jsh.model.vo.materials.AccountHeadModel;
import com.jsh.service.materials.AccountHeadIService;
import com.jsh.util.PageUtil;
import com.jsh.util.Tools;
/*
* 财务表头管理
* @author jishenghua qq:752718920
*/
@SuppressWarnings("serial")
public class AccountHeadAction extends BaseAction<AccountHeadModel>
{
private AccountHeadIService accountHeadService;
private AccountHeadModel model = new AccountHeadModel();
/*
* 获取MaxId
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public String getMaxId()
{
Map<String,List> mapData = model.getShowModel().getMap();
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try
{
accountHeadService.find(pageUtil,"maxId");
mapData.put("accountHeadMax", pageUtil.getPageList());
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>查找最大的Id信息异常", e);
model.getShowModel().setMsgTip("exceptoin");
}
return SUCCESS;
}
/**
* 增加财务
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加财务信息方法create()===================");
Boolean flag = false;
try
{
AccountHead accountHead = new AccountHead();
accountHead.setType(model.getType());
if(model.getOrganId()!=null){accountHead.setOrganId(new Supplier(model.getOrganId()));}
if(model.getHandsPersonId()!=null){accountHead.setHandsPersonId(new Person(model.getHandsPersonId()));}
accountHead.setChangeAmount(model.getChangeAmount());
accountHead.setTotalPrice(model.getTotalPrice());
if(model.getAccountId()!=null){accountHead.setAccountId(new Account(model.getAccountId()));}
accountHead.setBillNo(model.getBillNo());
try
{
accountHead.setBillTime(new Timestamp(Tools.parse(model.getBillTime(), "yyyy-MM-dd").getTime()));
}
catch (ParseException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>解析购买日期格式异常", e);
}
accountHead.setRemark(model.getRemark());
accountHeadService.create(accountHead);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加财务信息异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加财务信息回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加财务", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加财务编号为 "+ model.getBillNo() + " " + tipMsg + "！", "增加财务" + tipMsg));
Log.infoFileSync("==================结束调用增加财务方法create()===================");
}
/**
* 删除财务
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除财务信息方法delete()================");
try
{
accountHeadService.delete(model.getAccountHeadID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getAccountHeadID() + " 的财务异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除财务", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除财务ID为 "+ model.getAccountHeadID() + " " + tipMsg + "！", "删除财务" + tipMsg));
Log.infoFileSync("====================结束调用删除财务信息方法delete()================");
return SUCCESS;
}
/**
* 更新财务
* @return
*/
public void update()
{
Boolean flag = false;
try
{
AccountHead accountHead = accountHeadService.get(model.getAccountHeadID());
accountHead.setType(model.getType());
if(model.getOrganId()!=null){accountHead.setOrganId(new Supplier(model.getOrganId()));}
if(model.getHandsPersonId()!=null){accountHead.setHandsPersonId(new Person(model.getHandsPersonId()));}
accountHead.setChangeAmount(model.getChangeAmount());
accountHead.setTotalPrice(model.getTotalPrice());
if(model.getAccountId()!=null){accountHead.setAccountId(new Account(model.getAccountId()));}
accountHead.setBillNo(model.getBillNo());
try
{
accountHead.setBillTime(new Timestamp(Tools.parse(model.getBillTime(), "yyyy-MM-dd").getTime()));
}
catch (ParseException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>解析购买日期格式异常", e);
}
accountHead.setRemark(model.getRemark());
accountHeadService.update(accountHead);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改财务ID为 ： " + model.getAccountHeadID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改财务回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新财务", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新财务ID为 "+ model.getAccountHeadID() + " " + tipMsg + "！", "更新财务" + tipMsg));
}
/**
* 批量删除指定ID财务
* @return
*/
public String batchDelete()
{
try
{
accountHeadService.batchDelete(model.getAccountHeadIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除财务ID为：" + model.getAccountHeadIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除财务", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除财务ID为 "+ model.getAccountHeadIDs() + " " + tipMsg + "！", "批量删除财务" + tipMsg));
return SUCCESS;
}
/**
* 查找财务信息
* @return
*/
public void findBy()
{
try
{
PageUtil<AccountHead> pageUtil = new PageUtil<AccountHead>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
accountHeadService.find(pageUtil);
List<AccountHead> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(AccountHead accountHead:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", accountHead.getId());
item.put("OrganId", accountHead.getOrganId()==null?"":accountHead.getOrganId().getId());
item.put("OrganName", accountHead.getOrganId()==null?"":accountHead.getOrganId().getSupplier());
item.put("HandsPersonId", accountHead.getHandsPersonId()==null?"":accountHead.getHandsPersonId().getId());
item.put("HandsPersonName", accountHead.getHandsPersonId()==null?"":accountHead.getHandsPersonId().getName());
item.put("AccountId", accountHead.getAccountId()==null?"":accountHead.getAccountId().getId());
item.put("AccountName", accountHead.getAccountId()==null?"":accountHead.getAccountId().getName());
item.put("BillNo", accountHead.getBillNo());
item.put("BillTime", Tools.getCurrentMonth(accountHead.getBillTime()));
item.put("ChangeAmount", accountHead.getChangeAmount()==null?"":Math.abs(accountHead.getChangeAmount()));
item.put("TotalPrice", accountHead.getTotalPrice()==null?"":Math.abs(accountHead.getTotalPrice()));
item.put("Remark", accountHead.getRemark());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找财务信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询财务信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
{condition.put("BillNo_s_like", model.getBillNo());}
condition.put("Type_s_eq",model.getType());
condition.put("BillTime_s_gteq",model.getBeginTime());
condition.put("BillTime_s_lteq",model.getEndTime());
condition.put("Id_s_order","desc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public AccountHeadModel getModel()
{
return model;
}
public void setAccountHeadService(AccountHeadIService accountHeadService)
{
this.accountHeadService = accountHeadService;
}
}
src/com/jsh/action/materials/AccountItemAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.materials;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.AccountHead;
import com.jsh.model.po.AccountItem;
import com.jsh.model.po.Logdetails;
import com.jsh.model.po.Account;
import com.jsh.model.po.InOutItem;
import com.jsh.model.vo.materials.AccountItemModel;
import com.jsh.service.materials.AccountItemIService;
import com.jsh.util.PageUtil;
/*
* 财务明细管理(收支|收付款|转账)
* @author jishenghua qq:752718920
*/
@SuppressWarnings("serial")
public class AccountItemAction extends BaseAction<AccountItemModel>
{
private AccountItemIService accountItemService;
private AccountItemModel model = new AccountItemModel();
/**
* 保存明细
* @return
*/
public void saveDetials()
{
Log.infoFileSync("==================开始调用保存财务明细信息方法saveDetials()===================");
Boolean flag = false;
try
{
Long headerId=model.getHeaderId();
String inserted=model.getInserted();
String deleted=model.getDeleted();
String updated=model.getUpdated();
//转为json
JSONArray insertedJson = JSONArray.fromObject(inserted);
JSONArray deletedJson = JSONArray.fromObject(deleted);
JSONArray updatedJson = JSONArray.fromObject(updated);
if(null != insertedJson)
{
for(int i = 0;i < insertedJson.size(); i++)
{
AccountItem accountItem = new AccountItem();
JSONObject tempInsertedJson = JSONObject.fromObject(insertedJson.get(i));
accountItem.setHeaderId(new AccountHead(headerId));
if(tempInsertedJson.get("AccountId")!=null&&!tempInsertedJson.get("AccountId").equals("")){accountItem.setAccountId(new Account(tempInsertedJson.getLong("AccountId")));}
if(tempInsertedJson.get("InOutItemId")!=null&&!tempInsertedJson.get("InOutItemId").equals("")){accountItem.setInOutItemId(new InOutItem(tempInsertedJson.getLong("InOutItemId")));}
if(tempInsertedJson.get("EachAmount")!=null){accountItem.setEachAmount(tempInsertedJson.getDouble("EachAmount"));}
accountItem.setRemark(tempInsertedJson.getString("Remark"));
accountItemService.create(accountItem);
}
}
if(null != deletedJson)
{
for(int i = 0;i < deletedJson.size(); i++)
{
JSONObject tempDeletedJson = JSONObject.fromObject(deletedJson.get(i));
accountItemService.delete(tempDeletedJson.getLong("Id"));
}
}
if(null != updatedJson)
{
for(int i = 0;i < updatedJson.size(); i++)
{
JSONObject tempUpdatedJson = JSONObject.fromObject(updatedJson.get(i));
AccountItem accountItem = accountItemService.get(tempUpdatedJson.getLong("Id"));
accountItem.setHeaderId(new AccountHead(headerId));
if(tempUpdatedJson.get("AccountId")!=null&&!tempUpdatedJson.get("AccountId").equals("")){accountItem.setAccountId(new Account(tempUpdatedJson.getLong("AccountId")));}
if(tempUpdatedJson.get("InOutItemId")!=null&&!tempUpdatedJson.get("InOutItemId").equals("")){accountItem.setInOutItemId(new InOutItem(tempUpdatedJson.getLong("InOutItemId")));}
if(tempUpdatedJson.get("EachAmount")!=null){accountItem.setEachAmount(tempUpdatedJson.getDouble("EachAmount"));}
accountItem.setRemark(tempUpdatedJson.getString("Remark"));
accountItemService.create(accountItem);
}
}
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>保存财务明细信息异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>保存财务明细信息回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "保存财务明细", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "保存财务明细对应主表编号为 "+ model.getHeaderId() + " " + tipMsg + "！", "保存财务明细" + tipMsg));
Log.infoFileSync("==================结束调用保存财务明细方法saveDetials()===================");
}
/**
* 查找财务信息
* @return
*/
public void findBy()
{
try
{
PageUtil<AccountItem> pageUtil = new PageUtil<AccountItem>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
accountItemService.find(pageUtil);
List<AccountItem> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(AccountItem accountItem:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", accountItem.getId());
item.put("AccountId", accountItem.getAccountId()==null?"":accountItem.getAccountId().getId());
item.put("AccountName", accountItem.getAccountId()==null?"":accountItem.getAccountId().getName());
item.put("InOutItemId", accountItem.getInOutItemId()==null?"":accountItem.getInOutItemId().getId());
item.put("InOutItemName", accountItem.getInOutItemId()==null?"":accountItem.getInOutItemId().getName());
item.put("EachAmount", accountItem.getEachAmount());
item.put("Remark", accountItem.getRemark());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找财务信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询财务信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("HeaderId_n_eq", model.getHeaderId());
condition.put("Id_s_order","asc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public AccountItemModel getModel()
{
return model;
}
public void setAccountItemService(AccountItemIService accountItemService)
{
this.accountItemService = accountItemService;
}
}
src/com/jsh/action/materials/DepotHeadAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.materials;
import java.io.IOException;
import java.sql.Timestamp;
import java.text.ParseException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.Account;
import com.jsh.model.po.Depot;
import com.jsh.model.po.DepotHead;
import com.jsh.model.po.Logdetails;
import com.jsh.model.po.Person;
import com.jsh.model.po.Supplier;
import com.jsh.model.vo.materials.DepotHeadModel;
import com.jsh.service.materials.DepotHeadIService;
import com.jsh.util.PageUtil;
import com.jsh.util.Tools;
/*
* 单据表头管理
* @author jishenghua qq:752718920
*/
@SuppressWarnings("serial")
public class DepotHeadAction extends BaseAction<DepotHeadModel>
{
private DepotHeadIService depotHeadService;
private DepotHeadModel model = new DepotHeadModel();
/*
* 获取MaxId
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public String getMaxId()
{
Map<String,List> mapData = model.getShowModel().getMap();
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try
{
depotHeadService.find(pageUtil,"maxId");
mapData.put("depotHeadMax", pageUtil.getPageList());
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>查找最大的Id信息异常", e);
model.getShowModel().setMsgTip("exceptoin");
}
return SUCCESS;
}
/**
* 增加仓管通
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加仓管通信息信息方法create()===================");
Boolean flag = false;
try
{
DepotHead depotHead = new DepotHead();
depotHead.setType(model.getType());
depotHead.setSubType(model.getSubType());
depotHead.setProjectId(new Depot(model.getProjectId()));
depotHead.setNumber(model.getNumber());
depotHead.setOperPersonName(getUser().getUsername());
depotHead.setCreateTime(new Timestamp(new Date().getTime()));
try
{
depotHead.setOperTime(new Timestamp(Tools.parse(model.getOperTime(), "yyyy-MM-dd").getTime()));
}
catch (ParseException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>解析购买日期格式异常", e);
}
if(model.getOrganId()!=null){depotHead.setOrganId(new Supplier(model.getOrganId()));}
if(model.getHandsPersonId()!=null){depotHead.setHandsPersonId(new Person(model.getHandsPersonId()));}
if(model.getAccountId()!=null){depotHead.setAccountId(new Account(model.getAccountId()));}
depotHead.setChangeAmount(model.getChangeAmount());
if(model.getAllocationProjectId()!=null){depotHead.setAllocationProjectId(new Depot(model.getAllocationProjectId()));}
depotHead.setTotalPrice(model.getTotalPrice());
depotHead.setRemark(model.getRemark());
depotHeadService.create(depotHead);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加仓管通信息异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加仓管通信息回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加仓管通", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加仓管通编号为 "+ model.getNumber() + " " + tipMsg + "！", "增加仓管通" + tipMsg));
Log.infoFileSync("==================结束调用增加仓管通方法create()===================");
}
/**
* 删除仓管通
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除仓管通信息方法delete()================");
try
{
depotHeadService.delete(model.getDepotHeadID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getDepotHeadID() + " 的仓管通异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除仓管通", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除仓管通ID为 "+ model.getDepotHeadID() + " " + tipMsg + "！", "删除仓管通" + tipMsg));
Log.infoFileSync("====================结束调用删除仓管通信息方法delete()================");
return SUCCESS;
}
/**
* 更新仓管通
* @return
*/
public void update()
{
Boolean flag = false;
try
{
DepotHead depotHead = depotHeadService.get(model.getDepotHeadID());
depotHead.setType(model.getType());
depotHead.setSubType(model.getSubType());
depotHead.setProjectId(new Depot(model.getProjectId()));
depotHead.setNumber(model.getNumber());
depotHead.setOperPersonName(getUser().getUsername());
try
{
depotHead.setOperTime(new Timestamp(Tools.parse(model.getOperTime(), "yyyy-MM-dd").getTime()));
}
catch (ParseException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>解析入库时间格式异常", e);
}
if(model.getOrganId()!=null){depotHead.setOrganId(new Supplier(model.getOrganId()));}
if(model.getHandsPersonId()!=null){depotHead.setHandsPersonId(new Person(model.getHandsPersonId()));}
if(model.getAccountId()!=null){depotHead.setAccountId(new Account(model.getAccountId()));}
depotHead.setChangeAmount(model.getChangeAmount());
if(model.getAllocationProjectId()!=null){depotHead.setAllocationProjectId(new Depot(model.getAllocationProjectId()));}
depotHead.setTotalPrice(model.getTotalPrice());
depotHead.setRemark(model.getRemark());
depotHeadService.update(depotHead);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改仓管通ID为 ： " + model.getDepotHeadID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改仓管通回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新仓管通", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新仓管通ID为 "+ model.getDepotHeadID() + " " + tipMsg + "！", "更新仓管通" + tipMsg));
}
/**
* 批量删除指定ID仓管通
* @return
*/
public String batchDelete()
{
try
{
depotHeadService.batchDelete(model.getDepotHeadIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除仓管通ID为：" + model.getDepotHeadIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除仓管通", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除仓管通ID为 "+ model.getDepotHeadIDs() + " " + tipMsg + "！", "批量删除仓管通" + tipMsg));
return SUCCESS;
}
/**
* 查找仓管通信息
* @return
*/
public void findBy()
{
try
{
PageUtil<DepotHead> pageUtil = new PageUtil<DepotHead>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
depotHeadService.find(pageUtil);
List<DepotHead> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(DepotHead depotHead:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", depotHead.getId());
item.put("ProjectId", depotHead.getProjectId()==null?"":depotHead.getProjectId().getId());
item.put("ProjectName", depotHead.getProjectId()==null?"":depotHead.getProjectId().getName());
item.put("Number", depotHead.getNumber());
item.put("OperPersonName", depotHead.getOperPersonName());
item.put("CreateTime", Tools.getCurrentMonth(depotHead.getCreateTime()));
item.put("OperTime", Tools.getCurrentMonth(depotHead.getOperTime()));
item.put("OrganId", depotHead.getOrganId()==null?"":depotHead.getOrganId().getId());
item.put("OrganName", depotHead.getOrganId()==null?"":depotHead.getOrganId().getSupplier());
item.put("HandsPersonId", depotHead.getHandsPersonId()==null?"":depotHead.getHandsPersonId().getId());
item.put("HandsPersonName", depotHead.getHandsPersonId()==null?"":depotHead.getHandsPersonId().getName());
item.put("AccountId", depotHead.getAccountId()==null?"":depotHead.getAccountId().getId());
item.put("AccountName", depotHead.getAccountId()==null?"":depotHead.getAccountId().getName());
item.put("ChangeAmount", depotHead.getChangeAmount()==null?"":Math.abs(depotHead.getChangeAmount()));
item.put("AllocationProjectId", depotHead.getAllocationProjectId()==null?"":depotHead.getAllocationProjectId().getId());
item.put("AllocationProjectName", depotHead.getAllocationProjectId()==null?"":depotHead.getAllocationProjectId().getName());
item.put("TotalPrice", depotHead.getTotalPrice()==null?"":Math.abs(depotHead.getTotalPrice()));
item.put("Remark", depotHead.getRemark());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找仓管通信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询仓管通信息结果异常", e);
}
}
/**
* 查找进销存_根据月份(报表)
* @return
*/
public void findByMonth() {
try
{
PageUtil<DepotHead> pageUtil = new PageUtil<DepotHead>();
pageUtil.setPageSize(1000);
pageUtil.setCurPage(1);
pageUtil.setAdvSearch(getConditionHead());
depotHeadService.find(pageUtil);
List<DepotHead> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
String headId = "";
if(null != dataList)
{
for(DepotHead depotHead:dataList)
{
headId = headId + depotHead.getId() + ",";
}
}
if(headId!="") {
headId = headId.substring(0, headId.lastIndexOf(","));
}
outer.put("HeadIds", headId);
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找仓管通信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询仓管通信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
if(model.getAllocationProjectId()!=null)
{condition.put("AllocationProjectId_n_eq", model.getAllocationProjectId());}
if(model.getProjectId()!=null)
{condition.put("ProjectId_n_eq", model.getProjectId());}
condition.put("Type_s_eq",model.getType());
condition.put("SubType_s_eq",model.getSubType());
condition.put("Number_s_like",model.getNumber());
condition.put("OperTime_s_gteq",model.getBeginTime());
condition.put("OperTime_s_lteq",model.getEndTime());
condition.put("Id_s_order","desc");
return condition;
}
private Map<String,Object> getConditionHead()
{
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("OperTime_s_lteq",model.getMonthTime() + "-31 00:00:00");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public DepotHeadModel getModel()
{
return model;
}
public void setDepotHeadService(DepotHeadIService depotHeadService)
{
this.depotHeadService = depotHeadService;
}
}
src/com/jsh/action/materials/DepotItemAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.materials;
import java.io.File;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletResponse;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.util.AssetConstants;
import com.jsh.util.JshException;
import com.jsh.model.po.Asset;
import com.jsh.model.po.DepotHead;
import com.jsh.model.po.DepotItem;
import com.jsh.model.po.Logdetails;
import com.jsh.model.po.Material;
import com.jsh.model.vo.materials.DepotItemModel;
import com.jsh.service.materials.DepotHeadIService;
import com.jsh.service.materials.DepotItemIService;
import com.jsh.util.PageUtil;
import com.jsh.util.Tools;
/*
* 单据明细管理
* @author jishenghua qq:752718920
*/
@SuppressWarnings("serial")
public class DepotItemAction extends BaseAction<DepotItemModel>
{
private DepotItemIService depotItemService;
private DepotItemModel model = new DepotItemModel();
/**
* action返回excel结果
*/
public static final String EXCEL = "excel";
/**
* 保存明细
* @return
*/
public void saveDetials()
{
Log.infoFileSync("==================开始调用保存仓管通明细信息方法saveDetials()===================");
Boolean flag = false;
try
{
Long headerId=model.getHeaderId();
String inserted=model.getInserted();
String deleted=model.getDeleted();
String updated=model.getUpdated();
//转为json
JSONArray insertedJson = JSONArray.fromObject(inserted);
JSONArray deletedJson = JSONArray.fromObject(deleted);
JSONArray updatedJson = JSONArray.fromObject(updated);
if(null != insertedJson)
{
for(int i = 0;i < insertedJson.size(); i++)
{
DepotItem depotItem = new DepotItem();
JSONObject tempInsertedJson = JSONObject.fromObject(insertedJson.get(i));
depotItem.setHeaderId(new DepotHead(headerId));
depotItem.setMaterialId(new Material(tempInsertedJson.getLong("MaterialId")));
depotItem.setOperNumber(tempInsertedJson.getDouble("OperNumber"));
if(tempInsertedJson.get("UnitPrice")!=null){depotItem.setUnitPrice(tempInsertedJson.getDouble("UnitPrice"));}
if(tempInsertedJson.get("AllPrice")!=null){depotItem.setAllPrice(tempInsertedJson.getDouble("AllPrice"));}
depotItem.setRemark(tempInsertedJson.getString("Remark"));
depotItemService.create(depotItem);
}
}
if(null != deletedJson)
{
for(int i = 0;i < deletedJson.size(); i++)
{
JSONObject tempDeletedJson = JSONObject.fromObject(deletedJson.get(i));
depotItemService.delete(tempDeletedJson.getLong("Id"));
}
}
if(null != updatedJson)
{
for(int i = 0;i < updatedJson.size(); i++)
{
JSONObject tempUpdatedJson = JSONObject.fromObject(updatedJson.get(i));
DepotItem depotItem = depotItemService.get(tempUpdatedJson.getLong("Id"));
depotItem.setMaterialId(new Material(tempUpdatedJson.getLong("MaterialId")));
depotItem.setOperNumber(tempUpdatedJson.getDouble("OperNumber"));
if(tempUpdatedJson.get("UnitPrice")!=null){depotItem.setUnitPrice(tempUpdatedJson.getDouble("UnitPrice"));}
if(tempUpdatedJson.get("AllPrice")!=null){depotItem.setAllPrice(tempUpdatedJson.getDouble("AllPrice"));}
depotItem.setRemark(tempUpdatedJson.getString("Remark"));
depotItemService.create(depotItem);
}
}
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>保存仓管通明细信息异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>保存仓管通明细信息回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "保存仓管通明细", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "保存仓管通明细对应主表编号为 "+ model.getHeaderId() + " " + tipMsg + "！", "保存仓管通明细" + tipMsg));
Log.infoFileSync("==================结束调用保存仓管通明细方法saveDetials()===================");
}
/**
* 查找仓管通信息
* @return
*/
public void findBy()
{
try
{
PageUtil<DepotItem> pageUtil = new PageUtil<DepotItem>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
depotItemService.find(pageUtil);
List<DepotItem> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(DepotItem depotItem:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", depotItem.getId());
item.put("MaterialId", depotItem.getMaterialId()==null?"":depotItem.getMaterialId().getId());
String MaterialName = ((depotItem.getMaterialId().getModel().equals(""))?"":""+depotItem.getMaterialId().getModel())+" "+depotItem.getMaterialId().getName()
+((depotItem.getMaterialId().getColor() == null)?"(":"("+depotItem.getMaterialId().getColor()) + ")"
+((depotItem.getMaterialId().getUnit() == null)?"(":"("+depotItem.getMaterialId().getUnit()) + ")";
item.put("MaterialName", MaterialName);
item.put("OperNumber", depotItem.getOperNumber());
item.put("UnitPrice", depotItem.getUnitPrice());
item.put("AllPrice", depotItem.getAllPrice());
item.put("Remark", depotItem.getRemark());
item.put("Img", depotItem.getImg());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找仓管通信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询仓管通信息结果异常", e);
}
}
/**
* 查找进销存
* @return
*/
public void findByAll()
{
try
{
PageUtil<DepotItem> pageUtil = new PageUtil<DepotItem>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getConditionALL());
depotItemService.find(pageUtil);
List<DepotItem> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(DepotItem depotItem:dataList)
{
JSONObject item = new JSONObject();
Integer prevSum = sumNumber("入库",depotItem.getMaterialId().getId(),model.getMonthTime(),true) - sumNumber("出库",depotItem.getMaterialId().getId(),model.getMonthTime(),true);
Integer InSum = sumNumber("入库",depotItem.getMaterialId().getId(),model.getMonthTime(),false);
Integer OutSum = sumNumber("出库",depotItem.getMaterialId().getId(),model.getMonthTime(),false);
item.put("Id", depotItem.getId());
item.put("MaterialId", depotItem.getMaterialId()==null?"":depotItem.getMaterialId().getId());
item.put("MaterialName", depotItem.getMaterialId().getName());
item.put("MaterialModel", depotItem.getMaterialId().getModel());
item.put("MaterialColor", depotItem.getMaterialId().getColor());
item.put("prevSum", prevSum);
item.put("InSum", InSum);
item.put("OutSum", OutSum);
item.put("thisSum", prevSum + InSum - OutSum);
item.put("thisAllPrice", depotItem.getUnitPrice() * (prevSum + InSum - OutSum));
item.put("UnitPrice", depotItem.getUnitPrice());
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询信息结果异常", e);
}
}
/**
* 进货统计
* @return
*/
public void buyIn()
{
try
{
PageUtil<DepotItem> pageUtil = new PageUtil<DepotItem>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getConditionALL());
depotItemService.find(pageUtil);
List<DepotItem> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(DepotItem depotItem:dataList)
{
JSONObject item = new JSONObject();
Integer InSum = sumNumberBuyOrSale("入库","采购",depotItem.getMaterialId().getId(),model.getMonthTime());
Integer OutSum = sumNumberBuyOrSale("出库","采购退货",depotItem.getMaterialId().getId(),model.getMonthTime());
Double InSumPrice = sumPriceBuyOrSale("入库","采购",depotItem.getMaterialId().getId(),model.getMonthTime());
Double OutSumPrice = sumPriceBuyOrSale("出库","采购退货",depotItem.getMaterialId().getId(),model.getMonthTime());
item.put("Id", depotItem.getId());
item.put("MaterialId", depotItem.getMaterialId()==null?"":depotItem.getMaterialId().getId());
item.put("MaterialName", depotItem.getMaterialId().getName());
item.put("MaterialModel", depotItem.getMaterialId().getModel());
item.put("MaterialColor", depotItem.getMaterialId().getColor());
item.put("InSum", InSum);
item.put("OutSum", OutSum);
item.put("InSumPrice", InSumPrice);
item.put("OutSumPrice", OutSumPrice);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询信息结果异常", e);
}
}
/**
* 销售统计
* @return
*/
public void saleOut()
{
try
{
PageUtil<DepotItem> pageUtil = new PageUtil<DepotItem>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getConditionALL());
depotItemService.find(pageUtil);
List<DepotItem> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(DepotItem depotItem:dataList)
{
JSONObject item = new JSONObject();
Integer OutSum = sumNumberBuyOrSale("出库","销售",depotItem.getMaterialId().getId(),model.getMonthTime());
Integer InSum = sumNumberBuyOrSale("入库","销售退货",depotItem.getMaterialId().getId(),model.getMonthTime());
Double OutSumPrice = sumPriceBuyOrSale("出库","销售",depotItem.getMaterialId().getId(),model.getMonthTime());
Double InSumPrice = sumPriceBuyOrSale("入库","销售退货",depotItem.getMaterialId().getId(),model.getMonthTime());
item.put("Id", depotItem.getId());
item.put("MaterialId", depotItem.getMaterialId()==null?"":depotItem.getMaterialId().getId());
item.put("MaterialName", depotItem.getMaterialId().getName());
item.put("MaterialModel", depotItem.getMaterialId().getModel());
item.put("MaterialColor", depotItem.getMaterialId().getColor());
item.put("OutSum", OutSum);
item.put("InSum", InSum);
item.put("OutSumPrice", OutSumPrice);
item.put("InSumPrice", InSumPrice);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询信息结果异常", e);
}
}
/**
* 统计总计金额
* @return
*/
public void totalCountMoney()
{
try
{
PageUtil<DepotItem> pageUtil = new PageUtil<DepotItem>();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
pageUtil.setAdvSearch(getConditionALL());
depotItemService.find(pageUtil);
List<DepotItem> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
Double thisAllPrice = 0.0;
if(null != dataList)
{
for(DepotItem depotItem:dataList)
{
Integer prevSum = sumNumber("入库",depotItem.getMaterialId().getId(),model.getMonthTime(),true) - sumNumber("出库",depotItem.getMaterialId().getId(),model.getMonthTime(),true);
Integer InSum = sumNumber("入库",depotItem.getMaterialId().getId(),model.getMonthTime(),false);
Integer OutSum = sumNumber("出库",depotItem.getMaterialId().getId(),model.getMonthTime(),false);
thisAllPrice = thisAllPrice + depotItem.getUnitPrice() * (prevSum + InSum - OutSum);
}
}
outer.put("totalCount", thisAllPrice);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询信息结果异常", e);
}
}
/**
* 导出excel表格
* @return
*/
@SuppressWarnings("unchecked")
public String exportExcel()
{
Log.infoFileSync("===================调用导出信息action方法exportExcel开始=======================");
try
{
PageUtil<DepotItem> pageUtil = new PageUtil<DepotItem>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getConditionALL());
depotItemService.find(pageUtil);
List<DepotItem> dataList = pageUtil.getPageList();
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(DepotItem depotItem:dataList)
{
JSONObject item = new JSONObject();
Integer prevSum = sumNumber("入库",depotItem.getMaterialId().getId(),model.getMonthTime(),true) - sumNumber("出库",depotItem.getMaterialId().getId(),model.getMonthTime(),true);
Integer InSum = sumNumber("入库",depotItem.getMaterialId().getId(),model.getMonthTime(),false);
Integer OutSum = sumNumber("出库",depotItem.getMaterialId().getId(),model.getMonthTime(),false);
item.put("Id", depotItem.getId());
item.put("MaterialId", depotItem.getMaterialId()==null?"":depotItem.getMaterialId().getId());
item.put("MaterialName", depotItem.getMaterialId().getName());
item.put("MaterialModel", depotItem.getMaterialId().getModel());
item.put("MaterialColor", depotItem.getMaterialId().getColor());
item.put("prevSum", prevSum);
item.put("InSum", InSum);
item.put("OutSum", OutSum);
item.put("thisSum", prevSum + InSum - OutSum);
item.put("thisAllPrice", depotItem.getUnitPrice() * (prevSum + InSum - OutSum));
item.put("UnitPrice", depotItem.getUnitPrice());
dataArray.add(item);
}
}
String isCurrentPage = "allPage";
model.setFileName(Tools.changeUnicode("report.xls",model.getBrowserType()));
model.setExcelStream(depotItemService.exmportExcel(isCurrentPage,dataArray));
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>>>>调用导出信息action方法exportExcel异常",e);
model.getShowModel().setMsgTip("export excel exception");
}
Log.infoFileSync("===================调用导出信息action方法exportExcel结束==================");
return EXCEL;
}
@SuppressWarnings("unchecked")
public Integer sumNumber(String type,Long MId,String MonthTime, Boolean isPrev) {
Integer sumNumber = 0;
String allNumber = "";
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try {
depotItemService.findByType(pageUtil, type, MId, MonthTime, isPrev);
allNumber = pageUtil.getPageList().toString();
allNumber = allNumber.substring(1,allNumber.length()-1);
if(allNumber.equals("null")){
allNumber = "0";
}
allNumber = allNumber.replace(".0", "");
} catch (JshException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sumNumber = Integer.parseInt(allNumber);
return sumNumber;
}
@SuppressWarnings("unchecked")
public Integer sumNumberBuyOrSale(String type,String subType,Long MId,String MonthTime) {
Integer sumNumber = 0;
String allNumber = "";
String sumType = "Number";
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try {
depotItemService.buyOrSale(pageUtil, type, subType, MId, MonthTime, sumType);
allNumber = pageUtil.getPageList().toString();
allNumber = allNumber.substring(1,allNumber.length()-1);
if(allNumber.equals("null")){
allNumber = "0";
}
allNumber = allNumber.replace(".0", "");
} catch (JshException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sumNumber = Integer.parseInt(allNumber);
return sumNumber;
}
@SuppressWarnings("unchecked")
public Double sumPriceBuyOrSale(String type,String subType,Long MId,String MonthTime) {
Double sumPrice = 0.0;
String allPrice = "";
String sumType = "Price";
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try {
depotItemService.buyOrSale(pageUtil, type, subType, MId, MonthTime, sumType);
allPrice = pageUtil.getPageList().toString();
allPrice = allPrice.substring(1,allPrice.length()-1);
if(allPrice.equals("null")){
allPrice = "0";
}
allPrice = allPrice.replace(".0", "");
} catch (JshException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sumPrice = Double.parseDouble(allPrice);
return sumPrice;
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("HeaderId_n_eq", model.getHeaderId());
condition.put("Id_s_order","asc");
return condition;
}
private Map<String,Object> getConditionALL()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("HeaderId_s_in", model.getHeadIds());
condition.put("MaterialId_s_in", model.getMaterialIds());
condition.put("MaterialId_s_gb","aaa");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public DepotItemModel getModel()
{
return model;
}
public void setDepotItemService(DepotItemIService depotItemService)
{
this.depotItemService = depotItemService;
}
}
src/com/jsh/action/materials/MaterialAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.materials;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.DepotHead;
import com.jsh.model.po.Material;
import com.jsh.model.po.Logdetails;
import com.jsh.model.po.MaterialCategory;
import com.jsh.model.po.Supplier;
import com.jsh.model.vo.materials.MaterialModel;
import com.jsh.service.materials.MaterialIService;
import com.jsh.util.PageUtil;
/*
* 商品管理
* @author jishenghua qq:752718920
*/
@SuppressWarnings("serial")
public class MaterialAction extends BaseAction<MaterialModel>
{
private MaterialIService materialService;
private MaterialModel model = new MaterialModel();
/**
* 增加商品
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加商品信息方法create()===================");
Boolean flag = false;
try
{
Material material = new Material();
material.setMaterialCategory(new MaterialCategory(model.getCategoryId()));
material.setName(model.getName());
material.setModel(model.getModel());
material.setColor(model.getColor());
material.setUnit(model.getUnit());
material.setRetailPrice(model.getRetailPrice());
material.setLowPrice(model.getLowPrice());
material.setPresetPriceOne(model.getPresetPriceOne());
material.setPresetPriceTwo(model.getPresetPriceTwo());
material.setRemark(model.getRemark());
materialService.create(material);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加商品信息异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加商品信息回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加商品", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加商品名称为 "+ model.getName() + " " + tipMsg + "！", "增加商品" + tipMsg));
Log.infoFileSync("==================结束调用增加商品方法create()===================");
}
/**
* 删除商品
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除商品信息方法delete()================");
try
{
materialService.delete(model.getMaterialID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getMaterialID() + " 的商品异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除商品", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除商品ID为 "+ model.getMaterialID() + " " + tipMsg + "！", "删除商品" + tipMsg));
Log.infoFileSync("====================结束调用删除商品信息方法delete()================");
return SUCCESS;
}
/**
* 更新商品
* @return
*/
public void update()
{
Boolean flag = false;
try
{
Material material = materialService.get(model.getMaterialID());
material.setMaterialCategory(new MaterialCategory(model.getCategoryId()));
material.setName(model.getName());
material.setModel(model.getModel());
material.setColor(model.getColor());
material.setUnit(model.getUnit());
material.setRetailPrice(model.getRetailPrice());
material.setLowPrice(model.getLowPrice());
material.setPresetPriceOne(model.getPresetPriceOne());
material.setPresetPriceTwo(model.getPresetPriceTwo());
material.setRemark(model.getRemark());
material.setName(model.getName());
materialService.update(material);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改商品ID为 ： " + model.getMaterialID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改商品回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新商品", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新商品ID为 "+ model.getMaterialID() + " " + tipMsg + "！", "更新商品" + tipMsg));
}
/**
* 批量删除指定ID商品
* @return
*/
public String batchDelete()
{
try
{
materialService.batchDelete(model.getMaterialIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除商品ID为：" + model.getMaterialIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除商品", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除商品ID为 "+ model.getMaterialIDs() + " " + tipMsg + "！", "批量删除商品" + tipMsg));
return SUCCESS;
}
/**
* 查找商品信息
* @return
*/
public void findBy()
{
try
{
PageUtil<Material> pageUtil = new PageUtil<Material>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
Long lei=model.getCategoryId();
if(1==lei) //判断值还真不能用String类型的判断
{
pageUtil.setAdvSearch(getCondition_all());
}
else if(1!=lei)
{
pageUtil.setAdvSearch(getCondition());
}
materialService.find(pageUtil);
List<Material> dataList = pageUtil.getPageList();
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Material material:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", material.getId());
item.put("Name", material.getName());
item.put("Model", material.getModel());
item.put("Color", material.getColor());
item.put("Unit", material.getUnit());
item.put("RetailPrice", material.getRetailPrice());
item.put("LowPrice", material.getLowPrice());
item.put("PresetPriceOne", material.getPresetPriceOne());
item.put("PresetPriceTwo", material.getPresetPriceTwo());
item.put("Remark", material.getRemark());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找商品信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询商品信息结果异常", e);
}
}
/**
* 查找商品信息-下拉框
* @return
*/
public void findBySelect()
{
try
{
PageUtil<Material> pageUtil = new PageUtil<Material>();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
pageUtil.setAdvSearch(getCondition_Select());
materialService.find(pageUtil);
List<Material> dataList = pageUtil.getPageList();
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(Material material:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", material.getId());
//名称
String MaterialName = ((material.getModel().equals(""))?"":""+material.getModel()) +" "+ material.getName()
+ ((material.getColor() == null)?"":"("+material.getColor() + ")")
+ ((material.getUnit() == null)?"":"("+material.getUnit() + ")");
item.put("MaterialName", MaterialName);
dataArray.add(item);
}
}
//回写查询结果
toClient(dataArray.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找供应商信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询供应商信息结果异常", e);
}
}
/**
* 查找商品信息-统计排序
* @return
*/
public void findByOrder()
{
try
{
PageUtil<Material> pageUtil = new PageUtil<Material>();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
pageUtil.setAdvSearch(getCondition_Order());
materialService.find(pageUtil);
List<Material> dataList = pageUtil.getPageList();
//存放数据json数组
JSONObject outer = new JSONObject();
String mId = "";
if(null != dataList)
{
for(Material material:dataList)
{
mId = mId + material.getId() + ",";
}
}
if(mId!="") {
mId = mId.substring(0, mId.lastIndexOf(","));
}
outer.put("mIds", mId);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>查找供应商信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>回写查询供应商信息结果异常", e);
}
}
/**
* 拼接搜索条件(查全部)
* @return
*/
private Map<String,Object> getCondition_all()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("Id_s_order", "asc");
return condition;
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("CategoryId_s_in", model.getCategoryIds());
condition.put("Id_s_order", "asc");
return condition;
}
/**
* 拼接搜索条件-下拉框
* @return
*/
private Map<String,Object> getCondition_Select()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("Id_s_order", "asc");
return condition;
}
/**
* 拼接搜索条件-下拉框
* @return
*/
private Map<String,Object> getCondition_Order()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("Name,Model_s_order", "asc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public MaterialModel getModel()
{
return model;
}
public void setMaterialService(MaterialIService materialService)
{
this.materialService = materialService;
}
}
src/com/jsh/action/materials/MaterialCategoryAction.java deleted 100644 → 0
View file @ 0b41f71a
package com.jsh.action.materials;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.dao.DataAccessException;
import com.jsh.base.BaseAction;
import com.jsh.base.Log;
import com.jsh.model.po.MaterialCategory;
import com.jsh.model.po.Logdetails;
import com.jsh.model.vo.materials.MaterialCategoryModel;
import com.jsh.service.materials.MaterialCategoryIService;
import com.jsh.util.PageUtil;
/*
* 商品类型管理
* @author jishenghua qq:752718920
*/
@SuppressWarnings("serial")
public class MaterialCategoryAction extends BaseAction<MaterialCategoryModel>
{
private MaterialCategoryIService materialCategoryService;
private MaterialCategoryModel model = new MaterialCategoryModel();
@SuppressWarnings({ "rawtypes", "unchecked" })
public String getBasicData()
{
Map<String,List> mapData = model.getShowModel().getMap();
PageUtil pageUtil = new PageUtil();
pageUtil.setPageSize(0);
pageUtil.setCurPage(0);
try
{
Map<String,Object> condition = pageUtil.getAdvSearch();
condition.put("ParentId_n_eq", model.getParentId());
condition.put("Id_n_neq", 1);
condition.put("Id_s_order", "asc");
materialCategoryService.find(pageUtil);
mapData.put("materialCategoryList", pageUtil.getPageList());
}
catch (Exception e)
{
Log.errorFileSync(">>>>>>>>>>>>>查找商品类别信息异常", e);
model.getShowModel().setMsgTip("exceptoin");
}
return SUCCESS;
}
/**
* 增加商品类别
* @return
*/
public void create()
{
Log.infoFileSync("==================开始调用增加商品类别信息方法create()===================");
Boolean flag = false;
try
{
MaterialCategory materialCategory = new MaterialCategory();
materialCategory.setMaterialCategory(new MaterialCategory(model.getParentId()));
materialCategory.setCategoryLevel(model.getCategoryLevel());
materialCategory.setName(model.getName());
materialCategoryService.create(materialCategory);
//========标识位===========
flag = true;
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>增加商品类别信息异常", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>增加商品类别信息回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "增加商品类别", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "增加商品类别名称为 "+ model.getName() + " " + tipMsg + "！", "增加商品类别" + tipMsg));
Log.infoFileSync("==================结束调用增加商品类别方法create()===================");
}
/**
* 删除商品类别
* @return
*/
public String delete()
{
Log.infoFileSync("====================开始调用删除商品类别信息方法delete()================");
try
{
materialCategoryService.delete(model.getMaterialCategoryID());
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>删除ID为 " + model.getMaterialCategoryID() + " 的商品类别异常", e);
tipMsg = "失败";
tipType = 1;
}
model.getShowModel().setMsgTip(tipMsg);
logService.create(new Logdetails(getUser(), "删除商品类别", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "删除商品类别ID为 "+ model.getMaterialCategoryID() + " " + tipMsg + "！", "删除商品类别" + tipMsg));
Log.infoFileSync("====================结束调用删除商品类别信息方法delete()================");
return SUCCESS;
}
/**
* 更新商品类别
* @return
*/
public void update()
{
Boolean flag = false;
try
{
MaterialCategory materialCategory = materialCategoryService.get(model.getMaterialCategoryID());
materialCategory.setMaterialCategory(new MaterialCategory(model.getParentId()));
materialCategory.setCategoryLevel(model.getCategoryLevel());
materialCategory.setName(model.getName());
materialCategoryService.update(materialCategory);
flag = true;
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>修改商品类别ID为 ： " + model.getMaterialCategoryID() + "信息失败", e);
flag = false;
tipMsg = "失败";
tipType = 1;
}
finally
{
try
{
toClient(flag.toString());
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>修改商品类别回写客户端结果异常", e);
}
}
logService.create(new Logdetails(getUser(), "更新商品类别", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "更新商品类别ID为 "+ model.getMaterialCategoryID() + " " + tipMsg + "！", "更新商品类别" + tipMsg));
}
/**
* 批量删除指定ID商品类别
* @return
*/
public String batchDelete()
{
try
{
materialCategoryService.batchDelete(model.getMaterialCategoryIDs());
model.getShowModel().setMsgTip("成功");
//记录操作日志使用
tipMsg = "成功";
tipType = 0;
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>批量删除商品类别ID为：" + model.getMaterialCategoryIDs() + "信息异常", e);
tipMsg = "失败";
tipType = 1;
}
logService.create(new Logdetails(getUser(), "批量删除商品类别", model.getClientIp(),
new Timestamp(System.currentTimeMillis())
, tipType, "批量删除商品类别ID为 "+ model.getMaterialCategoryIDs() + " " + tipMsg + "！", "批量删除商品类别" + tipMsg));
return SUCCESS;
}
/**
* 查找商品类别信息
* @return
*/
public void findBy()
{
try
{
PageUtil<MaterialCategory> pageUtil = new PageUtil<MaterialCategory>();
pageUtil.setPageSize(model.getPageSize());
pageUtil.setCurPage(model.getPageNo());
pageUtil.setAdvSearch(getCondition());
materialCategoryService.find(pageUtil);
List<MaterialCategory> dataList = pageUtil.getPageList();
//开始拼接json数据
// {"total":28,"rows":[
// {"productid":"AV-CB-01","attr1":"Adult Male","itemid":"EST-18"}
// ]}
JSONObject outer = new JSONObject();
outer.put("total", pageUtil.getTotalCount());
//存放数据json数组
JSONArray dataArray = new JSONArray();
if(null != dataList)
{
for(MaterialCategory materialCategory:dataList)
{
JSONObject item = new JSONObject();
item.put("Id", materialCategory.getId());
item.put("ParentId", materialCategory.getMaterialCategory().getId());
item.put("ParentName", materialCategory.getMaterialCategory().getName());
item.put("CategoryLevel", materialCategory.getCategoryLevel());
item.put("Name", materialCategory.getName());
item.put("op", 1);
dataArray.add(item);
}
}
outer.put("rows", dataArray);
//回写查询结果
toClient(outer.toString());
}
catch (DataAccessException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>查找商品类别信息异常", e);
}
catch (IOException e)
{
Log.errorFileSync(">>>>>>>>>>>>>>>>>>>回写查询商品类别信息结果异常", e);
}
}
/**
* 拼接搜索条件
* @return
*/
private Map<String,Object> getCondition()
{
/**
* 拼接搜索条件
*/
Map<String,Object> condition = new HashMap<String,Object>();
condition.put("ParentId_n_eq", model.getParentId());
condition.put("Id_n_neq", 1);
condition.put("Id_s_order", "asc");
return condition;
}
//=============以下spring注入以及Model驱动公共方法，与Action处理无关==================
@Override
public MaterialCategoryModel getModel()
{
return model;
}
public void setMaterialCategoryService(MaterialCategoryIService materialCategoryService)
{
this.materialCategoryService = materialCategoryService;
}
}
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment