Skip to content

S
store-system
Commit 9c5bc464 authored by wyh's avatar wyh
Browse files
Options

新增 批量

parent 0a146a21
Hide whitespace changes
Inline Side-by-side
Showing with 505 additions and 416 deletions
2code/server/store-system/src/main/java/cn/com/fqy/controller/mapi/WebWorkerController.java
View file @ 9c5bc464
package cn.com.fqy.controller.mapi; package cn.com.fqy.controller.mapi;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map;
import javax.annotation.Resource; import javax.annotation.Resource;
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.ResponseBody;
import cn.com.fqy.common.ResultInfo; import cn.com.fqy.common.ResultInfo;
import cn.com.fqy.common.constants.Constant; import cn.com.fqy.common.constants.Constant;
import cn.com.fqy.core.common.PageFinder; import cn.com.fqy.core.common.PageFinder;
import cn.com.fqy.core.model.Advert;
import cn.com.fqy.core.model.Query; import cn.com.fqy.core.model.Query;
import cn.com.fqy.core.model.Store; import cn.com.fqy.core.model.Store;
import cn.com.fqy.core.model.Worker; import cn.com.fqy.core.model.Worker;
...@@ -67,8 +67,9 @@ public class WebWorkerController { ...@@ -67,8 +67,9 @@ public class WebWorkerController {
*/ */
@RequestMapping("workerDetails") @RequestMapping("workerDetails")
@ResponseBody @ResponseBody
public ResultInfo<Worker> workerDetails(String workerId){ public ResultInfo<Map<String,Object>> workerDetails(String workerId){
ResultInfo<Worker> resultInfo = new ResultInfo<>(); ResultInfo<Map<String,Object>> resultInfo = new ResultInfo<>();
Map<String,Object> map = new HashMap<>();
if(workerId == null || "".equals(workerId)) { if(workerId == null || "".equals(workerId)) {
resultInfo.setCode("0"); resultInfo.setCode("0");
resultInfo.setMsg("员工参数为空"); resultInfo.setMsg("员工参数为空");
...@@ -76,8 +77,38 @@ public class WebWorkerController { ...@@ -76,8 +77,38 @@ public class WebWorkerController {
} }
Worker res = workerService.getWorker(workerId); Worker res = workerService.getWorker(workerId);
if (null != res ) { if (null != res ) {
Store store = storeService.getStore(res.getStoreId());
if(null != store) {
map.put("workerId",res.getWorkerId());
map.put("workerName",res.getWorkerName());
map.put("workerAge",res.getWorkerAge());
map.put("workerNumber",res.getWorkerNumber());
map.put("workerBirthday",res.getWorkerBirthday());
map.put("workerAncestral",res.getWorkerAncestral());
map.put("workerBust",res.getWorkerBust());
map.put("workerHeight",res.getWorkerHeight());
map.put("workerHipline",res.getWorkerHipline());
map.put("workerHomePic",res.getWorkerHomePic());
map.put("workerPic",res.getWorkerPic());
map.put("workerResume",res.getWorkerResume());
map.put("workerSex",res.getWorkerSex());
map.put("workerWaist",res.getWorkerWaist());
map.put("workerWeight",res.getWorkerWeight());
map.put("storeId",res.getStoreId());
map.put("brief",res.getBrief());
map.put("clicks",res.getClicks());
map.put("matureTime",res.getMatureTime());
map.put("serialNumber",res.getSerialNumber());
map.put("storeName",res.getStoreName());
map.put("storeBrief",store.getBrief());
map.put("storeCityName",store.getCityName());
map.put("storeProvince",store.getProvince());
map.put("storeCounty",store.getCounty());
map.put("storeHomePic",store.getStoreHomePic());
map.put("storePosition",store.getStorePosition());
}
resultInfo.setCode("1"); resultInfo.setCode("1");
resultInfo.setData(res); resultInfo.setData(map);
}else { }else {
resultInfo.setCode("0"); resultInfo.setCode("0");
resultInfo.setMsg("员工信息丢失"); resultInfo.setMsg("员工信息丢失");
......
2code/server/store-system/src/main/java/cn/com/fqy/controller/mgt/WorkerController.java
View file @ 9c5bc464
...@@ -114,4 +114,25 @@ public class WorkerController extends BaseController { ...@@ -114,4 +114,25 @@ public class WorkerController extends BaseController {
} }
return result; return result;
} }
/**
* 批量审核
* @param workerIds
* @return
*/
@RequestMapping("batchWorkers")
@ResponseBody
public ResultInfo<Worker> batchWorkers(String[] workerIds) {
return workerService.batchWorkerUpdate(workerIds, getOperator());
}
/**
* 批量展示
* @param workerIds
* @return
*/
@RequestMapping("batchWorkerShop")
@ResponseBody
public ResultInfo<Worker> batchWorkerShop(String[] workerIds) {
return workerService.batchWorkerShopping(workerIds, getOperator());
}
} }
2code/server/store-system/src/main/java/cn/com/fqy/core/service/WorkerService.java
View file @ 9c5bc464
package cn.com.fqy.core.service; package cn.com.fqy.core.service;
import java.util.List; import java.util.List;
import cn.com.fqy.common.Operator; import cn.com.fqy.common.Operator;
import cn.com.fqy.common.ResultInfo; import cn.com.fqy.common.ResultInfo;
import cn.com.fqy.core.common.BaseService; import cn.com.fqy.core.common.BaseService;
import cn.com.fqy.core.common.PageFinder; import cn.com.fqy.core.common.PageFinder;
import cn.com.fqy.core.model.Query; import cn.com.fqy.core.model.Query;
import cn.com.fqy.core.model.Worker; import cn.com.fqy.core.model.SysUser;
import cn.com.fqy.core.model.Worker;
/**
* Worker 服务接口类 /**
*/ * Worker 服务接口类
public interface WorkerService extends BaseService { */
public interface WorkerService extends BaseService {
/**
* 根据查询条件，查询并返回Worker的列表 /**
* @param q 查询条件 * 根据查询条件，查询并返回Worker的列表
* @return * @param q 查询条件
*/ * @return
public List<Worker> getWorkerList(Query q); */
public List<Worker> getWorkerList(Query q);
/**
* 根据查询条件，分页查询并返回Worker的分页结果 /**
* @param q 查询条件 * 根据查询条件，分页查询并返回Worker的分页结果
* @return * @param q 查询条件
*/ * @return
public PageFinder<Worker> getWorkerPagedList(Query q); */
public PageFinder<Worker> getWorkerPagedList(Query q);
/**
* 根据主键，查询并返回一个Worker对象 /**
* @param id 主键id * 根据主键，查询并返回一个Worker对象
* @return * @param id 主键id
*/ * @return
public Worker getWorker(String id); */
public Worker getWorker(String id);
/**
* 根据主键数组，查询并返回一组Worker对象 /**
* @param ids 主键数组，数组中的主键值应当无重复值，如有重复值时，则返回的列表长度可能小于传入的数组长度 * 根据主键数组，查询并返回一组Worker对象
* @return * @param ids 主键数组，数组中的主键值应当无重复值，如有重复值时，则返回的列表长度可能小于传入的数组长度
*/ * @return
public List<Worker> getWorkerByIds(String[] ids); */
public List<Worker> getWorkerByIds(String[] ids);
/**
* 根据主键，删除特定的Worker记录 /**
* @param id 主键id * 根据主键，删除特定的Worker记录
* @param operator 操作人对象 * @param id 主键id
* @return * @param operator 操作人对象
*/ * @return
public ResultInfo<Worker> delWorker(String id, Operator operator); */
public ResultInfo<Worker> delWorker(String id, Operator operator);
/**
* 新增一条Worker记录，执行成功后传入对象及返回对象的主键属性值不为null /**
* @param worker 新增的Worker数据（如果无特殊需求，新增对象的主键值请保留为null） * 新增一条Worker记录，执行成功后传入对象及返回对象的主键属性值不为null
* @param operator 操作人对象 * @param worker 新增的Worker数据（如果无特殊需求，新增对象的主键值请保留为null）
* @return * @param operator 操作人对象
*/ * @return
public ResultInfo<Worker> addWorker(Worker worker, Operator operator); */
public ResultInfo<Worker> addWorker(Worker worker, Operator operator);
/**
* 根据主键，更新一条Worker记录 /**
* @param worker 更新的Worker数据，且其主键不能为空 * 根据主键，更新一条Worker记录
* @param operator 操作人对象 * @param worker 更新的Worker数据，且其主键不能为空
* @return * @param operator 操作人对象
*/ * @return
public ResultInfo<Worker> updateWorker(Worker worker, Operator operator); */
public ResultInfo<Worker> updateWorker(Worker worker, Operator operator);
/**
* 生成主键 /**
* @return * 生成主键
*/ * @return
public String generatePK(); */
public String generatePK();
/**
* 为Worker对象设置默认值 /**
* @param obj * 为Worker对象设置默认值
*/ * @param obj
public void fillDefaultValues(Worker obj); */
public void fillDefaultValues(Worker obj);
/**
* 根据 一组ID 查询返回一个对象集合 /**
* @param ids * 根据 一组ID 查询返回一个对象集合
* @return * @param ids
*/ * @return
public List<Worker> getWorkerSByIds(String[] ids); */
public List<Worker> getWorkerSByIds(String[] ids);
} /**
* 根据 一组ID 修改一组数据
* @param workerId
* @return
*/
public ResultInfo<Worker> batchWorkerUpdate(String[] workerIds,Operator operator);
public ResultInfo<Worker> batchWorkerShopping(String[] workerIds,Operator operator);
}
2code/server/store-system/src/main/java/cn/com/fqy/core/service/impl/WorkerServiceImpl.java
View file @ 9c5bc464
package cn.com.fqy.core.service.impl; package cn.com.fqy.core.service.impl;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Date; import java.util.Date;
import java.util.List; import java.util.List;
import java.util.Random; import java.util.Random;
import javax.annotation.Resource; import javax.annotation.Resource;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport; import org.springframework.transaction.interceptor.TransactionAspectSupport;
import cn.com.fqy.common.Operator; import cn.com.fqy.common.Operator;
import cn.com.fqy.common.ResultInfo; import cn.com.fqy.common.ResultInfo;
import cn.com.fqy.common.constants.Constant; import cn.com.fqy.common.constants.Constant;
import cn.com.fqy.core.common.PageFinder; import cn.com.fqy.core.common.PageFinder;
import cn.com.fqy.core.dao.WorkerDao; import cn.com.fqy.core.dao.WorkerDao;
import cn.com.fqy.core.model.Query; import cn.com.fqy.core.model.Query;
import cn.com.fqy.core.model.Worker; import cn.com.fqy.core.model.SysUser;
import cn.com.fqy.core.service.WorkerService; import cn.com.fqy.core.model.Worker;
import cn.com.fqy.core.service.WorkerService;
/**
* Worker 服务实现类 /**
*/ * Worker 服务实现类
@Service */
public class WorkerServiceImpl implements WorkerService { @Service
public class WorkerServiceImpl implements WorkerService {
private static final Log log = LogFactory.getLog(WorkerServiceImpl.class);
private static final Log log = LogFactory.getLog(WorkerServiceImpl.class);
@Resource
private WorkerDao workerDao; @Resource
private WorkerDao workerDao;
/**
* 根据查询条件，查询并返回Worker的列表 /**
* @param q 查询条件 * 根据查询条件，查询并返回Worker的列表
* @return * @param q 查询条件
*/ * @return
@Transactional(propagation = Propagation.SUPPORTS) */
public List<Worker> getWorkerList(Query q) { @Transactional(propagation = Propagation.SUPPORTS)
List<Worker> list = null; public List<Worker> getWorkerList(Query q) {
try { List<Worker> list = null;
//直接调用Dao方法进行查询 try {
list = workerDao.queryAll(q); //直接调用Dao方法进行查询
} catch (Exception e) { list = workerDao.queryAll(q);
log.error(e.getMessage(), e); } catch (Exception e) {
} log.error(e.getMessage(), e);
//如list为null时，则改为返回一个空列表 }
list = list == null ? new ArrayList<Worker>(0) : list; //如list为null时，则改为返回一个空列表
return list; list = list == null ? new ArrayList<Worker>(0) : list;
} return list;
}
/**
* 根据查询条件，分页查询并返回Worker的分页结果 /**
* @param q 查询条件 * 根据查询条件，分页查询并返回Worker的分页结果
* @return * @param q 查询条件
*/ * @return
@Transactional(propagation = Propagation.SUPPORTS) */
public PageFinder<Worker> getWorkerPagedList(Query q) { @Transactional(propagation = Propagation.SUPPORTS)
PageFinder<Worker> page = new PageFinder<Worker>(); public PageFinder<Worker> getWorkerPagedList(Query q) {
PageFinder<Worker> page = new PageFinder<Worker>();
List<Worker> list = null;
long rowCount = 0L; List<Worker> list = null;
long rowCount = 0L;
try {
//调用dao查询满足条件的分页数据 try {
list = workerDao.pageList(q); //调用dao查询满足条件的分页数据
//调用dao统计满足条件的记录总数 list = workerDao.pageList(q);
rowCount = workerDao.count(q); //调用dao统计满足条件的记录总数
} catch (Exception e) { rowCount = workerDao.count(q);
log.error(e.getMessage(), e); } catch (Exception e) {
} log.error(e.getMessage(), e);
}
//如list为null时，则改为返回一个空列表
list = list == null ? new ArrayList<Worker>(0) : list; //如list为null时，则改为返回一个空列表
list = list == null ? new ArrayList<Worker>(0) : list;
//将分页数据和记录总数设置到分页结果对象中
page.setData(list); //将分页数据和记录总数设置到分页结果对象中
page.setRowCount(rowCount); page.setData(list);
page.setPageSize(q.getPageSize()); page.setRowCount(rowCount);
return page; page.setPageSize(q.getPageSize());
} return page;
}
/**
* 根据主键，查询并返回一个Worker对象 /**
* @param id 主键id * 根据主键，查询并返回一个Worker对象
* @return * @param id 主键id
*/ * @return
@Transactional(propagation = Propagation.SUPPORTS) */
public Worker getWorker(String id) { @Transactional(propagation = Propagation.SUPPORTS)
Worker obj = null; public Worker getWorker(String id) {
if (id == null || id.length() == 0) { //传入的主键无效时直接返回null Worker obj = null;
log.info(Constant.ERR_MSG_INVALID_ARG + " id = " + id); if (id == null || id.length() == 0) { //传入的主键无效时直接返回null
return obj; log.info(Constant.ERR_MSG_INVALID_ARG + " id = " + id);
} return obj;
try { }
//调用dao，根据主键查询 try {
obj = workerDao.get(id); //调用dao，根据主键查询
if(null != obj) { obj = workerDao.get(id);
if(obj.getClicks()== null || "".equals(obj.getClicks())) { if(null != obj) {
obj.setClicks(0); if(obj.getClicks()== null || "".equals(obj.getClicks())) {
} obj.setClicks(0);
Worker worker = new Worker(); }
worker.setWorkerId(obj.getWorkerId()); Worker worker = new Worker();
worker.setClicks(obj.getClicks()+1); worker.setWorkerId(obj.getWorkerId());
workerDao.update(worker); worker.setClicks(obj.getClicks()+1);
} workerDao.update(worker);
} catch (Exception e) { }
log.error(e.getMessage(), e); } catch (Exception e) {
} log.error(e.getMessage(), e);
}
return obj;
} return obj;
}
/**
* 根据主键数组，查询并返回一组Worker对象 /**
* @param ids 主键数组，数组中的主键值应当无重复值，如有重复值时，则返回的列表长度可能小于传入的数组长度 * 根据主键数组，查询并返回一组Worker对象
* @return * @param ids 主键数组，数组中的主键值应当无重复值，如有重复值时，则返回的列表长度可能小于传入的数组长度
*/ * @return
@Transactional(propagation = Propagation.SUPPORTS) */
public List<Worker> getWorkerByIds(String[] ids) { @Transactional(propagation = Propagation.SUPPORTS)
List<Worker> list = null; public List<Worker> getWorkerByIds(String[] ids) {
if (ids == null || ids.length == 0) { List<Worker> list = null;
log.info(Constant.ERR_MSG_INVALID_ARG + " ids is null or empty array."); if (ids == null || ids.length == 0) {
} else { log.info(Constant.ERR_MSG_INVALID_ARG + " ids is null or empty array.");
try { } else {
//调用dao，根据主键数组查询 try {
list = workerDao.getByIds(ids); //调用dao，根据主键数组查询
} catch (Exception e) { list = workerDao.getByIds(ids);
log.error(e.getMessage(), e); } catch (Exception e) {
} log.error(e.getMessage(), e);
} }
}
//如list为null时，则改为返回一个空列表
list = list == null ? new ArrayList<Worker>(0) : list; //如list为null时，则改为返回一个空列表
list = list == null ? new ArrayList<Worker>(0) : list;
return list;
} return list;
}
/**
* 根据主键，删除特定的Worker记录 /**
* @param id 主键id * 根据主键，删除特定的Worker记录
* @param operator 操作人对象 * @param id 主键id
* @return * @param operator 操作人对象
*/ * @return
@Transactional */
public ResultInfo<Worker> delWorker(String id, Operator operator) { @Transactional
ResultInfo<Worker> resultInfo = new ResultInfo<Worker>(); public ResultInfo<Worker> delWorker(String id, Operator operator) {
if (id == null || id.length() == 0) { //传入的主键无效时直接返回失败结果 ResultInfo<Worker> resultInfo = new ResultInfo<Worker>();
resultInfo.setCode(Constant.FAIL); if (id == null || id.length() == 0) { //传入的主键无效时直接返回失败结果
resultInfo.setMsg(Constant.ERR_MSG_INVALID_ARG ); resultInfo.setCode(Constant.FAIL);
log.info(Constant.ERR_MSG_INVALID_ARG + " id = " + id); resultInfo.setMsg(Constant.ERR_MSG_INVALID_ARG );
return resultInfo; log.info(Constant.ERR_MSG_INVALID_ARG + " id = " + id);
} return resultInfo;
try { }
//调用Dao执行删除，并判断删除语句执行结果 try {
int count = workerDao.delete(id); //调用Dao执行删除，并判断删除语句执行结果
if (count > 0) { int count = workerDao.delete(id);
resultInfo.setCode(Constant.SUCCESS); if (count > 0) {
} else { resultInfo.setCode(Constant.SUCCESS);
resultInfo.setCode(Constant.FAIL); } else {
resultInfo.setMsg(Constant.ERR_MSG_DATA_NOT_EXISTS); resultInfo.setCode(Constant.FAIL);
} resultInfo.setMsg(Constant.ERR_MSG_DATA_NOT_EXISTS);
} catch (Exception e) { }
log.error(e.getMessage(), e); } catch (Exception e) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); log.error(e.getMessage(), e);
resultInfo.setCode(Constant.FAIL); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
resultInfo.setMsg(Constant.ERR_MSG_EXCEPTION_CATCHED); resultInfo.setCode(Constant.FAIL);
} resultInfo.setMsg(Constant.ERR_MSG_EXCEPTION_CATCHED);
return resultInfo; }
} return resultInfo;
}
/**
* 新增一条Worker记录，执行成功后传入对象及返回对象的主键属性值不为null /**
* @param worker 新增的Worker数据（如果无特殊需求，新增对象的主键值请保留为null） * 新增一条Worker记录，执行成功后传入对象及返回对象的主键属性值不为null
* @param operator 操作人对象 * @param worker 新增的Worker数据（如果无特殊需求，新增对象的主键值请保留为null）
* @return * @param operator 操作人对象
*/ * @return
@Transactional */
public ResultInfo<Worker> addWorker(Worker worker, Operator operator) { @Transactional
ResultInfo<Worker> resultInfo = new ResultInfo<Worker>(); public ResultInfo<Worker> addWorker(Worker worker, Operator operator) {
ResultInfo<Worker> resultInfo = new ResultInfo<Worker>();
if (worker == null) { //传入参数无效时直接返回失败结果
resultInfo.setCode(Constant.FAIL); if (worker == null) { //传入参数无效时直接返回失败结果
resultInfo.setMsg(Constant.ERR_MSG_INVALID_ARG ); resultInfo.setCode(Constant.FAIL);
log.info(Constant.ERR_MSG_INVALID_ARG + " worker = " + worker); resultInfo.setMsg(Constant.ERR_MSG_INVALID_ARG );
} else { log.info(Constant.ERR_MSG_INVALID_ARG + " worker = " + worker);
try { } else {
//如果传入参数的主键为null，则调用生成主键的方法获取新的主键 try {
if (worker.getWorkerId() == null || "".equals(worker.getWorkerId())) { //如果传入参数的主键为null，则调用生成主键的方法获取新的主键
worker.setWorkerId(this.generatePK()); if (worker.getWorkerId() == null || "".equals(worker.getWorkerId())) {
} worker.setWorkerId(this.generatePK());
//如果传入的操作人不为null，则设置新增记录的操作人类型和操作人id }
if (operator != null) { //如果传入的操作人不为null，则设置新增记录的操作人类型和操作人id
worker.setOperatorType(operator.getOperatorType()); if (operator != null) {
worker.setOperatorId(operator.getOperatorId()); worker.setOperatorType(operator.getOperatorType());
} worker.setOperatorId(operator.getOperatorId());
}
//设置创建时间和更新时间为当前时间
Date now = new Date(); //设置创建时间和更新时间为当前时间
worker.setCreateTime(now); Date now = new Date();
worker.setUpdateTime(now); worker.setCreateTime(now);
worker.setUpdateTime(now);
//填充默认值
this.fillDefaultValues(worker); //填充默认值
this.fillDefaultValues(worker);
//调用Dao执行插入操作
workerDao.add(worker); //调用Dao执行插入操作
resultInfo.setCode(Constant.SUCCESS); workerDao.add(worker);
resultInfo.setData(worker); resultInfo.setCode(Constant.SUCCESS);
} catch (Exception e) { resultInfo.setData(worker);
log.error(e.getMessage(), e); } catch (Exception e) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); log.error(e.getMessage(), e);
resultInfo.setCode(Constant.FAIL); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
resultInfo.setMsg(Constant.ERR_MSG_EXCEPTION_CATCHED); resultInfo.setCode(Constant.FAIL);
} resultInfo.setMsg(Constant.ERR_MSG_EXCEPTION_CATCHED);
} }
}
return resultInfo;
} return resultInfo;
}
/**
* 根据主键，更新一条Worker记录 /**
* @param worker 更新的Worker数据，且其主键不能为空 * 根据主键，更新一条Worker记录
* @param operator 操作人对象 * @param worker 更新的Worker数据，且其主键不能为空
* @return * @param operator 操作人对象
*/ * @return
@Transactional */
public ResultInfo<Worker> updateWorker(Worker worker, Operator operator) { @Transactional
ResultInfo<Worker> resultInfo = new ResultInfo<Worker>(); public ResultInfo<Worker> updateWorker(Worker worker, Operator operator) {
ResultInfo<Worker> resultInfo = new ResultInfo<Worker>();
if (worker == null || worker.getWorkerId() == null) { //传入参数无效时直接返回失败结果
resultInfo.setCode(Constant.FAIL); if (worker == null || worker.getWorkerId() == null) { //传入参数无效时直接返回失败结果
resultInfo.setMsg(Constant.ERR_MSG_INVALID_ARG ); resultInfo.setCode(Constant.FAIL);
log.info(Constant.ERR_MSG_INVALID_ARG + " worker = " + worker); resultInfo.setMsg(Constant.ERR_MSG_INVALID_ARG );
} else { log.info(Constant.ERR_MSG_INVALID_ARG + " worker = " + worker);
try { } else {
//如果传入的操作人不为null，则设置更新记录的操作人类型和操作人id try {
if (operator != null) { //如果传入的操作人不为null，则设置更新记录的操作人类型和操作人id
worker.setOperatorType(operator.getOperatorType()); if (operator != null) {
worker.setOperatorId(operator.getOperatorId()); worker.setOperatorType(operator.getOperatorType());
} worker.setOperatorId(operator.getOperatorId());
}
//设置更新时间为当前时间
worker.setUpdateTime(new Date()); //设置更新时间为当前时间
worker.setUpdateTime(new Date());
//调用Dao执行更新操作，并判断更新语句执行结果
int count = workerDao.update(worker); //调用Dao执行更新操作，并判断更新语句执行结果
if (count > 0) { int count = workerDao.update(worker);
resultInfo.setCode(Constant.SUCCESS); if (count > 0) {
} else { resultInfo.setCode(Constant.SUCCESS);
resultInfo.setCode(Constant.FAIL); } else {
} resultInfo.setCode(Constant.FAIL);
resultInfo.setData(worker); }
} catch (Exception e) { resultInfo.setData(worker);
log.error(e.getMessage(), e); } catch (Exception e) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); log.error(e.getMessage(), e);
resultInfo.setCode(Constant.FAIL); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
resultInfo.setMsg(Constant.ERR_MSG_EXCEPTION_CATCHED); resultInfo.setCode(Constant.FAIL);
} resultInfo.setMsg(Constant.ERR_MSG_EXCEPTION_CATCHED);
} }
}
return resultInfo;
} return resultInfo;
}
/**
* 生成主键 /**
* @return * 生成主键
*/ * @return
public String generatePK() { */
return String.valueOf(new Date().getTime() * 1000000 + new Random().nextInt(1000000)); public String generatePK() {
} return String.valueOf(new Date().getTime() * 1000000 + new Random().nextInt(1000000));
}
/**
* 为Worker对象设置默认值 /**
* @param obj * 为Worker对象设置默认值
*/ * @param obj
public void fillDefaultValues(Worker obj) { */
if (obj != null) { public void fillDefaultValues(Worker obj) {
if(obj.getIsAuditing() == null) { if (obj != null) {
obj.setIsAuditing(0); if(obj.getIsAuditing() == null) {
} obj.setIsAuditing(0);
if(obj.getIsDeleted() == null) { }
obj.setIsDeleted(0); if(obj.getIsDeleted() == null) {
} obj.setIsDeleted(0);
if(obj.getIsShopping() == null) { }
obj.setIsShopping(0); if(obj.getIsShopping() == null) {
} obj.setIsShopping(0);
if(obj.getIsRecommend() == null) { }
obj.setIsRecommend(0); if(obj.getIsRecommend() == null) {
} obj.setIsRecommend(0);
} }
} }
}
/**
* 根据主键数组，查询并返回一组Worker对象 /**
* @param ids 主键数组，数组中的主键值应当无重复值，如有重复值时，则返回的列表长度可能小于传入的数组长度 * 根据主键数组，查询并返回一组Worker对象
* @return * @param ids 主键数组，数组中的主键值应当无重复值，如有重复值时，则返回的列表长度可能小于传入的数组长度
*/ * @return
@Transactional(propagation = Propagation.SUPPORTS) */
public List<Worker> getWorkerSByIds(String[] ids) { @Transactional(propagation = Propagation.SUPPORTS)
List<Worker> list = null; public List<Worker> getWorkerSByIds(String[] ids) {
if (ids == null || ids.length == 0) { List<Worker> list = null;
log.info(Constant.ERR_MSG_INVALID_ARG + " ids is null or empty array."); if (ids == null || ids.length == 0) {
} else { log.info(Constant.ERR_MSG_INVALID_ARG + " ids is null or empty array.");
try { } else {
//调用dao，根据主键数组查询 try {
list = workerDao.getWorkerByIds(ids); //调用dao，根据主键数组查询
} catch (Exception e) { list = workerDao.getWorkerByIds(ids);
log.error(e.getMessage(), e); } catch (Exception e) {
} log.error(e.getMessage(), e);
} }
}
//如list为null时，则改为返回一个空列表
list = list == null ? new ArrayList<Worker>(0) : list; //如list为null时，则改为返回一个空列表
list = list == null ? new ArrayList<Worker>(0) : list;
return list;
} return list;
} }
@Override
public ResultInfo<Worker> batchWorkerUpdate(String[] workerIds,Operator operator) {
ResultInfo<Worker> resultInfo = new ResultInfo<Worker>();
for (String id : workerIds) {
Worker worker =new Worker();
worker.setWorkerId(id);
worker.setIsAuditing(1);
resultInfo = updateWorker(worker,operator);
}
return resultInfo;
}
@Override
public ResultInfo<Worker> batchWorkerShopping(String[] workerIds, Operator operator) {
ResultInfo<Worker> resultInfo = new ResultInfo<Worker>();
for (String id : workerIds) {
Worker worker =new Worker();
worker.setWorkerId(id);
worker.setIsShopping(1);;
resultInfo = updateWorker(worker,operator);
}
return resultInfo;
}
}
Markdown is supported
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