hz-zhhq-app-service/greenH5modul/.svn/pristine/71/7141bf369a74e3cfc17609f3d1b...

3348 lines
175 KiB
Plaintext
Raw Normal View History

2025-01-21 13:12:35 +08:00
package com.nationalelectric.greenH5;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import javax.annotation.Resource;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang.ObjectUtils;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;
import org.hibernate.util.StringHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.gexin.fastjson.JSON;
import com.jysoft.card.controller.CardController;
import com.jysoft.card.service.GreenCard;
import com.jysoft.property.controller.PropertyController;
import com.jysoft.property.entity.GreenPropertyEntity;
import com.jysoft.questionnaire.controller.QuestionnaireController;
import com.jysoft.questionnaire.entity.GreenQuestionnaire;
import com.jysoft.visitor.controller.VisitorController;
import com.jysoft.weChat.controller.WechatController;
import com.jysoft.weChat.util.HttpUtil;
import com.jysoft.weChat.util.ParseUtil;
import com.jysoft.weChat.util.Wechatconfig;
import com.nationalelectirc.Constant.Constant;
import com.nationalelectirc.Constant.ConstantRegex;
import com.nationalelectirc.utils.RestResult;
import com.nationalelectirc.utils.Utils;
import com.nationalelectric.greenH5.DTO.GreenConstructDTO;
import com.nationalelectric.greenH5.DTO.GreenFoodOrderDetailDTO;
import com.nationalelectric.greenH5.DTO.GreenFoodOrderListDTO;
import com.nationalelectric.greenH5.DTO.GreenHaircutRemainDTO;
import com.nationalelectric.greenH5.DTO.GreenHouseDto;
import com.nationalelectric.greenH5.DTO.GreenMealTicketApplyDTO;
import com.nationalelectric.greenH5.DTO.GreenMealTicketDTO;
import com.nationalelectric.greenH5.DTO.UserDTO;
import com.nationalelectric.greenH5.po.GreenActiveInfo;
import com.nationalelectric.greenH5.po.GreenActiveSign;
import com.nationalelectric.greenH5.po.GreenConstructPersonInfo;
import com.nationalelectric.greenH5.po.GreenDictionaryInfo;
import com.nationalelectric.greenH5.po.GreenDrugsApply;
import com.nationalelectric.greenH5.po.GreenDrugsDetail;
import com.nationalelectric.greenH5.po.GreenDrugsPush;
import com.nationalelectric.greenH5.po.GreenEAccount;
import com.nationalelectric.greenH5.po.GreenFaultRepairInfo;
import com.nationalelectric.greenH5.po.GreenFoodFeature;
import com.nationalelectric.greenH5.po.GreenFoodLottery;
import com.nationalelectric.greenH5.po.GreenFoodOrderDetail;
import com.nationalelectric.greenH5.po.GreenFoodVote;
import com.nationalelectric.greenH5.po.GreenGeneralInspecton;
import com.nationalelectric.greenH5.po.GreenGrantAuth;
import com.nationalelectric.greenH5.po.GreenHaircutComment;
import com.nationalelectric.greenH5.po.GreenHaircutInfo;
import com.nationalelectric.greenH5.po.GreenInfoGrather;
import com.nationalelectric.greenH5.po.GreenLicenseplateApproval;
import com.nationalelectric.greenH5.po.GreenMinorItem;
import com.nationalelectric.greenH5.po.GreenParkInfo;
import com.nationalelectric.greenH5.po.GreenPhysicalBase;
import com.nationalelectric.greenH5.po.GreenPhysicalItem;
import com.nationalelectric.greenH5.po.GreenProblemCollect;
import com.nationalelectric.greenH5.po.GreenRentHouseApply;
import com.nationalelectric.greenH5.po.GreenReport;
import com.nationalelectric.greenH5.po.GreenRetinueInfo;
import com.nationalelectric.greenH5.po.GreenSeekmedicalRecord;
import com.nationalelectric.greenH5.po.GreenSpanRegister;
import com.nationalelectric.greenH5.po.GreenStaffCardInfo;
import com.nationalelectric.greenH5.po.GreenTempParkInfo;
import com.nationalelectric.greenH5.po.GreenUsecarApply;
import com.nationalelectric.greenH5.po.GreenUserInfo;
import com.nationalelectric.greenH5.po.GreenVisitor;
import com.nationalelectric.greenH5.po.GreenVisitorInfo;
import com.nationalelectric.greenH5.po.GreenVisitorRetinueInfo;
import com.nationalelectric.greenH5.po.GreenWashCarInfo;
import com.nationalelectric.greenH5.po.QueryParams;
import com.nationalelectric.greenH5.po.Result;
import com.nationalelectric.greenH5.po.TorderEvaluate;
import com.nationalelectric.greenH5.po.UserVo;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
/**
* <b>概述</b><br>
*
* <p>
* <b>功能</b><br>
* app主接口
*
* @author zhangkai
*
*/
@Controller
@RequestMapping("/mainInterface")
public class GreenMainInterfaceController {
private static final Pattern compile = Pattern.compile(ConstantRegex.REGEX_010);
@Resource
private GreenParkThirdController greenParkThirdController;
/**
* 访客预约controller
*/
@Resource
private GreenVisitorInfoController greenVisitorInfoController;
/**
* 员工卡controller
*/
@Resource
private GreenStaffCardInfoController greenStaffCardInfoController;
/**
* 临时停车controller
*/
@Resource
private GreenTempParkInfoController greenTempParkInfoController;
/**
* 故障报修controller
*/
@Resource
private GreenFaultRepairInfoController greenFaultRepairInfoController;
/**
* 理发预约controller
*/
@Resource
private GreenHaircutInfoController greenHaircutInfoController;
/**
* 餐卷controller
*/
@Resource
private GreenMealTicketController greenMealTicketController;
/**
* 餐卷applycontroller
*/
@Resource
private GreenMealTicketApplyController mealTicketApplyController;
/**
* 食堂订单
*/
@Resource
private GreenFoodOrderDetailController greenFoodOrderDetailController;
/**
* 用户订单
*/
@Resource
private GreenFoodOrderListController greenFoodOrderListController;
/**
* 菜品
*/
@Resource
private GreenFoodsMenuController greenFoodsMenuController;
/**
* 用户
*/
@Resource
private GreenUserInfoController greenUserInfoController;
/**
* 部门
*/
@Resource
private GreenDepartmentController greenDepartmentController;
/**
* 施工申请
*/
@Resource
private GreenConstructInfoController greenConstructInfoController;
/**
* 理发评论
*/
@Resource
private GreenHaircutCommentController greenHaircutCommentController;
/*
* 体检
*/
@Resource
private GreenPhysicalBaseController greenPhysicalBaseController;
/*
* 一般检查
*/
@Resource
private GreenGeneralInspectonController greenGeneralInspectonController;
/*
* 总检
*/
@Resource
private GreenPhysicalItemController greenPhysicalItemController;
/**
* 细项
*/
@Resource
private GreenMinorItemController greenMinorItemController;
/**
* 登录登出
*/
@Resource
private GreenLoginController greenLoginController;
/*
* 评价
*/
@Resource
private EvaluateController evaluateController;
/*
* 推荐菜
*/
@Resource
private FeatureController featureController;
@Resource
private GreenApplyController greenApplyController;
@Resource
private GreenSpanRegisterController greenSpanRegisterController;
@Resource
private WechatController wechatController;
@Resource
private HomeController HomeController;
@Resource
CameraManagerController cameraManagerController;
@Resource
private GreenGrantAuthController greenGrantAuthController;
/**
* 字典表
*/
@Resource
private GreenDictionaryInfoController greenDictionaryInfoController;
// 临时停车三级审批查看我的代办和我的审批
@Resource
private GreenParkThirdApproveController greenParkThirdApproveController;
@Resource
private GreenFoodLotterController lotteryController;
@Autowired
private GreenWashCarController greenWashCarController;
@Autowired
private GreenInfoGratherController greenInfoGratherController;
@Autowired
private GreenVisitorStatisticsController greenVisitorStatisticsController;
@Autowired
private GreenSysSettingController greenSysSettingController;
@Autowired
private EAccountController eaController;
@Autowired
private GreenLicenseplateApprovalController greenLicenseplateApprovalController;
@Autowired
private GreenParkInfoController greenParkInfoController;
@Autowired
private GreenParkRecordController greenParkRecordController;
@Autowired
private GreenMyHealthyController greenMyHealthyController;
@Autowired
private GreenEnterpriseController greenEnterpriseController;
@Autowired
private GreenDrugsApplyController greenDrugsApplyController;
@Autowired
private GreenUseCarApplyController greenUseCarApplyController;
@Autowired
private GreenCatagoryController greenCatagoryController;
@Autowired
private GreenExamController greenExamController;
@Autowired
private GreenCalendarController greenCalendarController;
@Autowired
private GreenSeekmedicalRecordController greenSeekmedicalRecordController;
@Autowired
private GreenStatisticsController greenStatisticsController;
@Autowired
private GreenHealthMsgController greenHealthMsgController;
@Autowired
private GreenDrugsPushController greenDrugsPushController;
@Autowired
private NewsInfoController newsInfoController;
@Autowired
private GreenReportController greenReportController;
@Autowired
private GreenActiveInfoController greenActiveInfoController;
@Autowired
private GreenMealCardController greenMealCardController;
@Autowired
private AppLoginController appLoginController;
@Autowired
private AppUpdateController appUpdateController;
@Autowired
private GreenProblemCollectController greenProblemCollectController;
@Autowired
private GreenNoticeController greenNoticeController;
@Autowired
private GreenMarketController greenMarketController;
@Autowired
private GreenMonitorController greenMonitorController;
@Autowired
private GreenWeekMenuController greenWeekMenuController;
@Autowired
private GreenServiceGuideController greenServiceGuideController;
@Autowired
private GreenBannerController greenBannerController;
@Autowired
private SingleLoginController singleLoginController;
@Autowired
private GreenHouseController greenHouseController;
@Autowired
private GreenEpidemicController greenEpidemicController;
@Autowired
private VisitorController visitorController;
@Autowired
private PropertyController propertyController;
@Autowired
private CardController cardController;
@Autowired
private GreenWeekMealController greenWeekMealController;
@Autowired
private QuestionnaireController questionnaireController;
// 审批相关模块接口(包括访客预约、临时停车申请、员工卡办理申请、故障报修申请、理发预约、餐券申请)
@SuppressWarnings("static-access")
@RequestMapping("/approvalModule")
public @ResponseBody RestResult approvalModule(HttpServletRequest request, HttpServletResponse response) {
String jsonStr = "";
try {
// 关闭数据防重放记录
// Utils.list.clear();
// 加密方式
byte buffer[];
// try {
buffer = getRequestPostBytes(request);
System.err.println("buffer");
jsonStr = new String(buffer, "UTF-8");
JSONObject jsonObject = JSONObject.fromObject(jsonStr.trim());
String method = jsonObject.getString("method");
String dataStr = jsonObject.getString("data");
JSONObject data = jsonObject.fromObject(dataStr);
System.err.println("jsonStr");
String checkTime = jsonObject.containsKey("checkTime") ? jsonObject.getString("checkTime")
: new Date().getTime() + "";
String clientId = jsonObject.containsKey("clientId") ? jsonObject.getString("clientId") : "";
System.err.println("调用方法名:" + method);
System.err.println("前端传参:" + data);
// 加密方式
// byte buffer[] = getRequestPostBytes(request);
// String jsonStr = new String(buffer, "UTF-8"); //
// System.out.println("===== body data:" + jsonStr);
// JSONObject jsonObject = JSONObject.fromObject(jsonStr);
// String sign = jsonObject.getString("sign");
// String body = jsonObject.getString("body");
// String checkTimeDate = jsonObject.getString("checkTime"); //
// String src = jsonObject.getString("src"); //
// cSystem.out.println("===== sign:" + sign); //
// System.out.println("===== body:" + body); //
// System.out.println("===== src:" + src); String md5Sign =
// MD5Util.encrypt(body); if (!sign.equalsIgnoreCase(md5Sign)) { //
// System.out.println("====== md5 error "); return new
// RestResult(Constant.FAILED, "请求失败[数据异常-1]"); }
// String bodyData = AesEncryptUtil.desEncrypt(body);
// // System.out.println("===== 解密 body data:" + bodyData); if
// (bodyData == null) { // System.out.println("====== aes error ");
// return new RestResult(Constant.FAILED, "请求失败[数据异常-2]"); }
// String checkTime = AesEncryptUtil.desEncrypt(checkTimeDate);
// boolean find = compile.matcher(checkTime).find(); if (!find &&
// checkTime == null) { return new RestResult(Constant.FAILED,
// "请求失败[数据异常-2]"); }
// JSONObject bodyObject = JSONObject.fromObject(bodyData);
// String method = bodyObject.getString("method"); JSONObject data =
// bodyObject.getJSONObject("data");
// CheckParamUtil.checkJsonValue(data);
// String code = data.getString("code");
// if (code.length() > 0) {
// String url =
// "https://api.weixin.qq.com/sns/oauth2/access_token?appid=" +
// Wechatconfig.appId + "&secret=" + Wechatconfig.appSecret +
// "&code=" + code + "&grant_type=authorization_code";
// String tokenString = HttpUtil.getHttpsResponse(url, "");
// System.out.println(tokenString);
// JSONObject tokenJson = new JSONObject().fromObject(tokenString);
//
// String openid = ParseUtil.parseText(tokenJson.get("openid"));
// String access_token =
// ParseUtil.parseText(tokenJson.get("access_token"));
//
// // 获取用户信息
//
// // httpGET请使用https协议
//
// String getUserUrl =
// "https://api.weixin.qq.com/sns/userinfo?access_token=" +
// access_token + "&openid=" + openid + "&lang=zh_CN";
// String userString = HttpUtil.getHttpsResponse(getUserUrl, "");
//
// String json = new String(userString.getBytes("ISO-8859-1"),
// "UTF-8");
//
// JSONObject resultObj = new JSONObject().fromObject(json);
// System.out.println(json);
// return new RestResult("1", "授权成功", resultObj);
// }else{
// return new RestResult("0", "授权失败");
// }
// 判断调用的接口
if ("greenVisitorInfo/saveVistorInfo".equals(method)) {// 访客预约保存
if (Utils.list.contains("greenVisitorInfo/saveVistorInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
}
Map<String, Class> mapVisitClass = new HashMap<String, Class>();
mapVisitClass.put("greenRetinueInfoList", GreenRetinueInfo.class);
GreenVisitorRetinueInfo greenVisitorRetinueInfo = (GreenVisitorRetinueInfo) JSONObject.toBean(data,
GreenVisitorRetinueInfo.class, mapVisitClass);
return greenVisitorInfoController.saveVistorInfo(greenVisitorRetinueInfo, request);
} else if ("greenVisitorInfo/updateVisitorStatus".equals(method)) {// 访客预约的审批
if (Utils.list.contains("greenVisitorInfo/updateStatus" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/updateStatus" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenVisitorInfoController.updateVisitorStatus(result);
} else if ("greenVisitorInfo/invite".equals(method)) {// 邀约的确认
if (Utils.list.contains("greenVisitorInfo/saveVistorInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
}
Map<String, Class> mapVisitClass = new HashMap<String, Class>();
mapVisitClass.put("greenRetinueInfoList", GreenRetinueInfo.class);
GreenVisitorRetinueInfo greenVisitorRetinueInfo = (GreenVisitorRetinueInfo) JSONObject.toBean(data,
GreenVisitorRetinueInfo.class, mapVisitClass);
return greenVisitorInfoController.saveInviteInfo(greenVisitorRetinueInfo, request);
} else if ("greenVisitorInfo/getMyApplyList".equals(method)) {// 查询我的申请列表和我的待办列表
if (Utils.list.contains("greenVisitorInfo/getMyApplyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/getMyApplyList" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenVisitorInfoController.getMyApplyList(result);
} else if ("greenVisitorInfo/getMyVisitorList".equals(method)) {// 查询我的预约申请列表和我的邀约列表
if (Utils.list.contains("greenVisitorInfo/getMyApplyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/getMyApplyList" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenVisitorInfoController.getMyVisitorList(result);
} else if ("greenVisitorInfo/getCirculationList".equals(method)) {// 查询我的预约申请列表和我的邀约列表
if (Utils.list.contains("greenVisitorInfo/getCirculationList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/getCirculationList" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenVisitorInfoController.getCirculationList(result);
} else if ("greenVisitorInfo/submitCirculation".equals(method)) {// 查询我的预约申请列表和我的邀约列表
if (Utils.list.contains("greenVisitorInfo/submitCirculation" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/submitCirculation" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenVisitorInfoController.submitCirculation(result);
} else if ("greenVisitorInfo/updateVisitorInfoBatch".equals(method)) {// 查询我的预约申请列表和我的邀约列表
if (Utils.list.contains("greenVisitorInfo/updateVisitorInfoBatch" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/updateVisitorInfoBatch" + checkTime);
}
JSONArray dataArr = data.getJSONArray("list");
try {
for (int i = 0; i < dataArr.size(); i++) {
JSONObject jb = dataArr.getJSONObject(i);
Result result = (Result) JSONObject.toBean(jb, Result.class);
greenVisitorInfoController.updateVisitorStatus(result);
}
return new RestResult(Constant.SUCCESS, "操作成功!");
} catch (Exception e) {
e.printStackTrace();
return new RestResult(Constant.FAILED, "处理失败");
}
// return
// greenVisitorInfoController.updateVisitorInfoBatch(result);
} else if ("greenVisitorInfo/submitCirculationBatch".equals(method)) {// 查询我的预约申请列表和我的邀约列表
if (Utils.list.contains("greenVisitorInfo/submitCirculationBatch" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/submitCirculationBatch" + checkTime);
}
JSONArray dataArr = data.getJSONArray("list");
try {
for (int i = 0; i < dataArr.size(); i++) {
JSONObject jb = dataArr.getJSONObject(i);
Result result = (Result) JSONObject.toBean(jb, Result.class);
greenVisitorInfoController.submitCirculation(result);
}
return new RestResult(Constant.SUCCESS, "操作成功!");
} catch (Exception e) {
e.printStackTrace();
return new RestResult(Constant.FAILED, "操作失败");
}
// return
// greenVisitorInfoController.updateVisitorInfoBatch(result);
} else if ("greenVisitorInfo/listReason".equals(method)) {// 查询访客预约理由列表
if (Utils.list.contains("greenVisitorInfo/listReason" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/listReason" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenVisitorInfoController.listReason(result);
} else if ("greenVisitorInfo/countMyApplyList".equals(method)) {// 统计我的申请列表和我的待办列表
if (Utils.list.contains("greenVisitorInfo/countMyApplyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/countMyApplyList" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenVisitorInfoController.countMyApplyList(result);
} else if ("greenVisitorInfo/getApplyInfo".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenVisitorInfo/getApplyInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/getApplyInfo" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenVisitorInfoController.getApplyInfo(result, request);
} else if ("greenVisitorInfo/updateStatus".equals(method)) {// 申请的审批
if (Utils.list.contains("greenVisitorInfo/updateStatus" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/updateStatus" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenVisitorInfoController.updateStatus(result);
} else if ("greenVisitorInfo/batchUpdateStatus".equals(method)) {// 批量审批
// @SuppressWarnings("unchecked")
// List<Map<String, Object>> result = (List<Map<String,
// Object>>) JSONObject.toBean(data, List.class);
// return greenVisitorInfoController.batchUpdateStatus(result);
return null;
} else if ("greenStaffCardInfo/saveStaffCardInfo".equals(method)) {// 保存员工卡申请信息
if (Utils.list.contains("greenStaffCardInfo/saveStaffCardInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenStaffCardInfo/saveStaffCardInfo" + checkTime);
}
GreenStaffCardInfo greenStaffCardInfo = (GreenStaffCardInfo) JSONObject.toBean(data,
GreenStaffCardInfo.class);
return greenStaffCardInfoController.saveStaffCardInfo(greenStaffCardInfo);
} else if ("greenTempParkInfo/saveTempParkInfo".equals(method)) {// 保存临时停车申请信息
if (Utils.list.contains("greenTempParkInfo/saveTempParkInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenTempParkInfo/saveTempParkInfo" + checkTime);
}
GreenTempParkInfo greenTempParkInfo = (GreenTempParkInfo) JSONObject.toBean(data,
GreenTempParkInfo.class);
return greenTempParkInfoController.saveTempParkInfo(greenTempParkInfo);
} else if ("greenFaultRepairInfo/saveFaultRepairInfo".equals(method)) {// 保存故障报修申请信息
if (Utils.list.contains("greenFaultRepairInfo/saveFaultRepairInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/saveFaultRepairInfo" + checkTime);
}
GreenFaultRepairInfo greenFaultRepairInfo = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.saveFaultRepairInfo(greenFaultRepairInfo);
} else if ("greenHaircutInfo/getHaircutBasicInfo".equals(method)) {// 获取提交理发预约前的基本信息
if (Utils.list.contains("greenHaircutInfo/getHaircutBasicInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutInfo/getHaircutBasicInfo" + checkTime);
}
GreenHaircutRemainDTO greenHaircutInfo = (GreenHaircutRemainDTO) JSONObject.toBean(data,
GreenHaircutRemainDTO.class);
return greenHaircutInfoController.getHaircutBasicInfo(greenHaircutInfo);
} else if ("greenHaircutInfo/saveHaircutInfo".equals(method)) {// 提交和修改理发预约信息
if (Utils.list.contains("greenHaircutInfo/saveHaircutInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutInfo/saveHaircutInfo" + checkTime);
}
GreenHaircutInfo greenHaircutInfo = (GreenHaircutInfo) JSONObject.toBean(data, GreenHaircutInfo.class);
return greenHaircutInfoController.saveHaircutInfo(greenHaircutInfo);
} else if ("greenHaircutInfo/remindForHairCut".equals(method)) {// 根据理发预约日期和时间段查询理发列表
if (Utils.list.contains("greenHaircutInfo/remindForHairCut" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutInfo/remindForHairCut" + checkTime);
}
GreenHaircutRemainDTO greenHaircutInfo = (GreenHaircutRemainDTO) JSONObject.toBean(data,
GreenHaircutRemainDTO.class);
return greenHaircutInfoController.remindForHairCut(greenHaircutInfo);
} else if ("greenHaircutInfo/cancleHaircut".equals(method)) {// 根据理发预约日期和时间段查询理发列表
if (Utils.list.contains("greenHaircutInfo/cancleHaircut" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutInfo/cancleHaircut" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenHaircutInfoController.cancleHaircut(map);
} else if ("greenHaircutInfo/getHaircutList".equals(method)) {// 根据理发预约日期和时间段查询理发列表
if (Utils.list.contains("greenHaircutInfo/getHaircutList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutInfo/getHaircutList" + checkTime);
}
GreenHaircutInfo greenHaircutInfo = (GreenHaircutInfo) JSONObject.toBean(data, GreenHaircutInfo.class);
return greenHaircutInfoController.getHaircutList(greenHaircutInfo);
} else if ("greenHaircutInfo/getHaircutInfoById".equals(method)) {// 根据理发预约日期和时间段查询理发列表
if (Utils.list.contains("greenHaircutInfo/getHaircutInfoById" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutInfo/getHaircutInfoById" + checkTime);
}
GreenHaircutInfo greenHaircutInfo = (GreenHaircutInfo) JSONObject.toBean(data, GreenHaircutInfo.class);
return greenHaircutInfoController.getHaircutInfoById(greenHaircutInfo);
} else if ("greenConstructInfo/saveConstructInfo".equals(method)) {// 提交施工申请
if (Utils.list.contains("greenConstructInfo/saveConstructInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenConstructInfo/saveConstructInfo" + checkTime);
}
Map<String, Class> vm = new HashMap<String, Class>();
vm.put("constructPersonList", GreenConstructPersonInfo.class);
GreenConstructDTO greenConstructInfo = (GreenConstructDTO) JSONObject.toBean(data,
GreenConstructDTO.class, vm);
return greenConstructInfoController.saveConstructInfo(greenConstructInfo);
} else if ("greenHaircutInfo/getHaircutInfoAndRemain".equals(method)) {// 根据id查询理发预约详情以及理发师预约余额
if (Utils.list.contains("greenHaircutInfo/getHaircutInfoAndRemain" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutInfo/getHaircutInfoAndRemain" + checkTime);
}
GreenHaircutInfo greenHaircutInfo = (GreenHaircutInfo) JSONObject.toBean(data, GreenHaircutInfo.class);
return greenHaircutInfoController.getHaircutInfoAndRemain(greenHaircutInfo);
} else if ("greenHaircutInfo/initHaircut".equals(method)) {// 初始化理发预约时加载理发余额等数据
if (Utils.list.contains("greenHaircutInfo/initHaircut" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutInfo/initHaircut" + checkTime);
}
// GreenHaircutRemainDTO greenHaircutInfo =
// (GreenHaircutRemainDTO) JSONObject.toBean(data,
// GreenHaircutRemainDTO.class);
return greenHaircutInfoController.initHaircut(data.getString("userId"));
} else if ("greenHaircutComment/saveHaircutComment".equals(method)) {// 保存理发评论信息
if (Utils.list.contains("greenHaircutComment/saveHaircutComment" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutComment/saveHaircutComment" + checkTime);
}
GreenHaircutComment greenHaircutComment = (GreenHaircutComment) JSONObject.toBean(data,
GreenHaircutComment.class);
return greenHaircutCommentController.saveHaircutComment(greenHaircutComment);
} else if ("greenHaircutComment/getHaircutComment".equals(method)) {// 根据id查询理发评论
if (Utils.list.contains("greenHaircutComment/getHaircutComment" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutComment/getHaircutComment" + checkTime);
}
GreenHaircutComment greenHaircutComment = (GreenHaircutComment) JSONObject.toBean(data,
GreenHaircutComment.class);
return greenHaircutCommentController.getHaircutComment(greenHaircutComment);
} else if ("greenHaircutInfo/getBasicInfoForBarber".equals(method)) {// 获取提交理发预约前的基本信息(理发店查看的页面)
if (Utils.list.contains("greenHaircutInfo/getBasicInfoForBarber" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutInfo/getBasicInfoForBarber" + checkTime);
}
GreenHaircutRemainDTO greenHaircutInfo = (GreenHaircutRemainDTO) JSONObject.toBean(data,
GreenHaircutRemainDTO.class);
return greenHaircutInfoController.getBasicInfoForBarber(greenHaircutInfo);
} else if ("greenHaircutInfo/initHaircutForBarber".equals(method)) {// 初始化理发预约时加载理发余额等数据(理发店查看的页面)
if (Utils.list.contains("greenHaircutInfo/initHaircutForBarber" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHaircutInfo/initHaircutForBarber" + checkTime);
}
GreenHaircutRemainDTO greenHaircutInfo = (GreenHaircutRemainDTO) JSONObject.toBean(data,
GreenHaircutRemainDTO.class);
return greenHaircutInfoController.initHaircutForBarber(greenHaircutInfo);
} else if ("greenMealTicket/scan".equals(method)) {// 餐券扫描-消费
// if (Utils.list.contains("greenMealTicket/scan" + checkTime))
// {
// return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
// } else {
// Utils.list.add("greenMealTicket/scan" + checkTime);
// }
// GreenMealTicketDTO greenMealTicketDTO = (GreenMealTicketDTO)
// JSONObject.toBean(data,
// GreenMealTicketDTO.class);
// return greenMealTicketController.scan(greenMealTicketDTO);
return null;
} else if ("greenMealTicketApply/apply".equals(method)) {// 餐券申请-领取
if (Utils.list.contains("greenMealTicketApply/apply" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMealTicketApply/apply" + checkTime);
}
GreenMealTicketApplyDTO greenMealTicketApplyDTO = (GreenMealTicketApplyDTO) JSONObject.toBean(data,
GreenMealTicketApplyDTO.class);
return mealTicketApplyController.apply(greenMealTicketApplyDTO);
} else if ("greenMealTicket/applyList".equals(method)) {// 餐券申请列表
if (Utils.list.contains("greenMealTicket/applyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMealTicket/applyList" + checkTime);
}
GreenMealTicketDTO greenMealTicketDTO = (GreenMealTicketDTO) JSONObject.toBean(data,
GreenMealTicketDTO.class);
return greenMealTicketController.applyList(greenMealTicketDTO);
} else if ("greenMealTicket/list".equals(method)) {// 餐券领取列表
if (Utils.list.contains("greenMealTicket/list" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMealTicket/list" + checkTime);
}
GreenMealTicketDTO greenMealTicketDTO = (GreenMealTicketDTO) JSONObject.toBean(data,
GreenMealTicketDTO.class);
return greenMealTicketController.list(greenMealTicketDTO);
} else if ("greenFoodOrderDetail/cancelOrder".equals(method)) {// 取消订单
if (Utils.list.contains("greenFoodOrderDetail/cancelOrder" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodOrderDetail/cancelOrder" + checkTime);
}
Map<String, Class> mapCancelClass = new HashMap<String, Class>();
mapCancelClass.put("orderDetails", GreenFoodOrderDetail.class);
GreenFoodOrderListDTO greenFoodOrderListDTO = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapCancelClass);
return greenFoodOrderDetailController.cancelOrder(greenFoodOrderListDTO);
} else if ("greenFoodOrderDetail/list".equals(method)) {// 我的订单列表
if (Utils.list.contains("greenFoodOrderDetail/list" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodOrderDetail/list" + checkTime);
}
Map<String, Class> mapOrderListClass = new HashMap<String, Class>();
mapOrderListClass.put("orderDetails", GreenFoodOrderDetail.class);
GreenFoodOrderListDTO greenFoodOrderListDTO = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapOrderListClass);
return greenFoodOrderDetailController.list(greenFoodOrderListDTO);
} else if ("greenFoodOrderDetail/toDaylist".equals(method)) {// 我的订单列表
if (Utils.list.contains("greenFoodOrderDetail/toDaylist" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodOrderDetail/toDaylist" + checkTime);
}
Map<String, Class> mapOrderListClass = new HashMap<String, Class>();
mapOrderListClass.put("orderDetails", GreenFoodOrderDetail.class);
GreenFoodOrderListDTO greenFoodOrderListDTO = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapOrderListClass);
return greenFoodOrderDetailController.toDaylist(greenFoodOrderListDTO);
} else if ("greenFoodOrderList/submitOrder".equals(method)) {// 提交订单
if (Utils.list.contains("greenFoodOrderList/submitOrder" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodOrderList/submitOrder" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
mapClass.put("orderDetails", GreenFoodOrderDetailDTO.class);
GreenFoodOrderListDTO greenfoodorderlists = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapClass);
return greenFoodOrderListController.submit(greenfoodorderlists);
} else if ("greenFoodOrderDetail/sellView".equals(method)) {// 食堂师傅-订单列表
if (Utils.list.contains("greenFoodOrderDetail/sellView" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodOrderDetail/sellView" + checkTime);
}
Map<String, Class> mapOrderMasterClass = new HashMap<String, Class>();
mapOrderMasterClass.put("orderDetails", GreenFoodOrderDetail.class);
GreenFoodOrderListDTO greenfoodorderlists = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapOrderMasterClass);
return greenFoodOrderDetailController.sellView(greenfoodorderlists);
} else if ("greenFoodOrderDetail/sellHot".equals(method)) {// 食堂师傅-订单列表
if (Utils.list.contains("greenFoodOrderDetail/sellHot" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodOrderDetail/sellHot" + checkTime);
}
Map<String, Class> mapOrderMasterClass = new HashMap<String, Class>();
mapOrderMasterClass.put("orderDetails", GreenFoodOrderDetail.class);
GreenFoodOrderListDTO greenfoodorderlists = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapOrderMasterClass);
return greenFoodOrderDetailController.sellHot(greenfoodorderlists);
} else if ("greenFoodOrderDetail/detail".equals(method)) {// 订单详情
if (Utils.list.contains("greenFoodOrderDetail/detail" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodOrderDetail/detail" + checkTime);
}
Map<String, Class> mapOrderDetailClass = new HashMap<String, Class>();
mapOrderDetailClass.put("orderDetails", GreenFoodOrderDetail.class);
GreenFoodOrderListDTO greenFoodOrderListDTO = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapOrderDetailClass);
return greenFoodOrderDetailController.detail(greenFoodOrderListDTO);
} else if ("greenFoodOrderDetail/listByLocation".equals(method)) {// 食堂师傅-订单列表
if (Utils.list.contains("greenFoodOrderDetail/listByLocation" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodOrderDetail/listByLocation" + checkTime);
}
Map<String, Class> mapOrderMasterClass = new HashMap<String, Class>();
mapOrderMasterClass.put("orderDetails", GreenFoodOrderDetail.class);
GreenFoodOrderListDTO greenfoodorderlists = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapOrderMasterClass);
return greenFoodOrderDetailController.listBylocation(greenfoodorderlists);
} else if ("greenFoodsMenu/list".equals(method)) {// 食堂菜品
if (Utils.list.contains("greenFoodsMenu/list" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodsMenu/list" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
// UserDTO userDTO = (UserDTO) JSONObject.toBean(data,
// UserDTO.class);
return greenFoodsMenuController.list(map);
} else if ("greenFoodsMenu/homeFood".equals(method)) {// 今日食谱
if (Utils.list.contains("greenFoodsMenu/homeFood" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodsMenu/homeFood" + checkTime);
}
UserDTO userDTO = (UserDTO) JSONObject.toBean(data, UserDTO.class);
return greenFoodsMenuController.homeFood(userDTO);
} else if ("greenDepartment/getAllDept".equals(method)) {// 获取所有部门
if (Utils.list.contains("greenDepartment/getAllDept" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDepartment/getAllDept" + checkTime);
}
return greenDepartmentController.getAllDept();
} else if ("greenUserInfo/buildNumber".equals(method)) {// 付款返回卡号、余额、时间戳
if (Utils.list.contains("greenUserInfo/buildNumber" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUserInfo/buildNumber" + checkTime);
}
UserVo user = (UserVo) JSONObject.toBean(data, UserVo.class);
return greenUserInfoController.buildNumber(user);
} else if ("greenUserInfo/listConsumRecords".equals(method)) {// 查询消费记录
if (Utils.list.contains("greenUserInfo/listConsumRecords" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUserInfo/listConsumRecords" + checkTime);
}
UserVo user = (UserVo) JSONObject.toBean(data, UserVo.class);
return greenUserInfoController.listConsumRecords(user);
} else if ("greenUserInfo/getBalance".equals(method)) {// 获取餐卡余额
if (Utils.list.contains("greenUserInfo/getBalance" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUserInfo/getBalance" + checkTime);
}
UserVo user = (UserVo) JSONObject.toBean(data, UserVo.class);
return greenUserInfoController.getBalance(user);
} else if ("greenUserInfo/cardConsum".equals(method)) {// 消费记录
if (Utils.list.contains("greenUserInfo/cardConsum" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUserInfo/cardConsum" + checkTime);
}
UserVo user = (UserVo) JSONObject.toBean(data, UserVo.class);
return greenUserInfoController.cardConsum(user);
} else if ("greenFaultRepairInfo/getBasicInfo".equals(method)) {// 获取故障报修选项数据
if (Utils.list.contains("greenFaultRepairInfo/getBasicInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/getBasicInfo" + checkTime);
}
return greenFaultRepairInfoController.getBasicInfo();
} else if ("greenVisitorInfo/getVisitorInfoTel".equals(method)) {// 根据访客手机号获取访客详情
if (Utils.list.contains("greenVisitorInfo/getVisitorInfoTel" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/getVisitorInfoTel" + checkTime);
}
GreenVisitorInfo greenVisitorInfo = (GreenVisitorInfo) JSONObject.toBean(data, GreenVisitorInfo.class);
return greenVisitorInfoController.getVisitorInfoTel(greenVisitorInfo);
} else if ("greenUserInfo/platformAuthen".equals(method)) {// 获取token
if (Utils.list.contains("greenUserInfo/platformAuthen" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUserInfo/platformAuthen" + checkTime);
}
GreenUserInfo greenUserInfo = (GreenUserInfo) JSONObject.toBean(data, GreenUserInfo.class);
return greenUserInfoController.platformAuthen(greenUserInfo);
} else if ("greenUserInfo/userMealNo".equals(method)) {// 校验用户是否绑定餐卡
if (Utils.list.contains("greenUserInfo/userMealNo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUserInfo/userMealNo" + checkTime);
}
GreenUserInfo greenUserInfo = (GreenUserInfo) JSONObject.toBean(data, GreenUserInfo.class);
return greenUserInfoController.userMealNo(greenUserInfo);
} else if ("greenPhysicalBase/physicalBaseinfo".equals(method)) {// 获取用户体检基础详情
if (Utils.list.contains("greenPhysicalBase/physicalBaseinfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenPhysicalBase/physicalBaseinfo" + checkTime);
}
GreenPhysicalBase greenPhysicalBase = (GreenPhysicalBase) JSONObject.toBean(data,
GreenPhysicalBase.class);
return greenPhysicalBaseController.greenPhysicalBase(greenPhysicalBase);
} else if ("greenGeneralInspecton/generalInspectonInfo".equals(method)) {// 获取一般检查
if (Utils.list.contains("greenGeneralInspecton/generalInspectonInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenGeneralInspecton/generalInspectonInfo" + checkTime);
}
GreenGeneralInspecton greenGeneralInspecton = (GreenGeneralInspecton) JSONObject.toBean(data,
GreenGeneralInspecton.class);
return greenGeneralInspectonController.generalInspecton(greenGeneralInspecton);
} else if ("greenPhysicalItem/physicalItemInfo".equals(method)) {// 总检
if (Utils.list.contains("greenPhysicalItem/physicalItemInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenPhysicalItem/physicalItemInfo" + checkTime);
}
GreenPhysicalItem greenPhysicalItem = (GreenPhysicalItem) JSONObject.toBean(data,
GreenPhysicalItem.class);
return greenPhysicalItemController.getPhysicalItemInfo(greenPhysicalItem);
} else if ("greenMinorItem/minorItemInfo".equals(method)) {// 根据流水号查看细项检查
if (Utils.list.contains("greenMinorItem/minorItemInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMinorItem/minorItemInfo" + checkTime);
}
GreenMinorItem greenMinorItem = (GreenMinorItem) JSONObject.toBean(data, GreenMinorItem.class);
return greenMinorItemController.getMinorItemInfo(greenMinorItem);
} else if ("greenPhysicalItem/physicalItemName".equals(method)) {// 根据用户体检
// 时间获取检查异常和具体名称
if (Utils.list.contains("greenPhysicalItem/physicalItemName" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenPhysicalItem/physicalItemName" + checkTime);
}
GreenMinorItem greenMinorItem = (GreenMinorItem) JSONObject.toBean(data, GreenMinorItem.class);
return greenPhysicalItemController.getPhysicalItemName(greenMinorItem);
} else if ("greenPhysicalBase/userInforIdCard".equals(method)) {// 根据用户id获取身份证号
if (Utils.list.contains("greenPhysicalBase/userInforIdCard" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenPhysicalBase/userInforIdCard" + checkTime);
}
UserVo greenUserInfo = (UserVo) JSONObject.toBean(data, UserVo.class);
return greenPhysicalBaseController.getUserInforIdCard(greenUserInfo);
} else if ("greenLogin/login".equals(method)) {// 根据用户id获取身份证号
System.err.println(method + "method");
if (Utils.list.contains("greenLogin/login" + checkTime)) {
System.err.println(method + "checkTime");
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenLogin/login" + checkTime);
System.err.println(method + "Utils.list.add");
}
System.err.println("greenUserInfo!");
UserVo greenUserInfo = (UserVo) JSONObject.toBean(data, UserVo.class);
System.err.println(greenUserInfo.toString() + "greenUserInfo");
return greenLoginController.login(greenUserInfo);
} else if ("greenLogin/logout".equals(method)) {// 根据用户id获取身份证号
System.err.println(method + "method");
if (Utils.list.contains("greenLogin/logout" + checkTime)) {
System.err.println(method + "checkTime");
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenLogin/logout" + checkTime);
System.err.println(method + "Utils.list.add");
}
UserVo greenUserInfo = (UserVo) JSONObject.toBean(data, UserVo.class);
System.err.println(greenUserInfo.toString() + "greenUserInfo");
return greenLoginController.logout(greenUserInfo);
} else if ("greenVisitorInfo/getVisitorList".equals(method)) {// 总检
if (Utils.list.contains("greenVisitorInfo/getVisitorList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/getVisitorList" + checkTime);
}
GreenPhysicalItem greenPhysicalItem = (GreenPhysicalItem) JSONObject.toBean(data,
GreenPhysicalItem.class);
return greenVisitorInfoController.getVisitorList(data, request);
} else if ("greenMealTicket/getMonthMealNum".equals(method)) {// 获取本月餐券剩余数量
if (Utils.list.contains("greenMealTicket/getMonthMealNum" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMealTicket/getMonthMealNum" + checkTime);
}
return greenMealTicketController.getMonthMealNum(data);
} else if ("greenVisitorInfo/saveVistorState".equals(method)) {// 获取字典表数据
if (Utils.list.contains("greenVisitorInfo/saveVistorState" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/saveVistorState" + checkTime);
}
return greenVisitorInfoController.saveVistorEndState(data, request);
} else if ("greenTempParkInfo/getPlateNumList".equals(method)) {// 获取字典表数据
if (Utils.list.contains("greenTempParkInfo/getPlateNumList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenTempParkInfo/getPlateNumList" + checkTime);
}
return greenTempParkInfoController.getPlateNumberList(data, request);
} else if ("greenDictionaryInfo/greenTypeInfo".equals(method)) {// 获取字典表数据
if (Utils.list.contains("greenDictionaryInfo/greenTypeInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDictionaryInfo/greenTypeInfo" + checkTime);
}
GreenDictionaryInfo greenDictionaryInfo = (GreenDictionaryInfo) JSONObject.toBean(data,
GreenDictionaryInfo.class);
return greenDictionaryInfoController.greenTypeInfo(greenDictionaryInfo);
} else if ("greenUserInfo/getParkRole".equals(method)) {// 获取临时停车审批权限人员信息
if (Utils.list.contains("greenUserInfo/getParkRole" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUserInfo/getParkRole" + checkTime);
}
UserVo greenUserInfo = (UserVo) JSONObject.toBean(data, UserVo.class);
return greenUserInfoController.getParkRole(greenUserInfo);
} else if ("getParkThirdApprove/getMyApplyList".equals(method)) {// 查询我的申请列表和我的待办列表(临时停车三级审批)
if (Utils.list.contains("getParkThirdApprove/getMyApplyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorInfo/getMyApplyList" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenParkThirdApproveController.getMyApplyList(result);
} else if ("getParkThirdApprove/updateStatus".equals(method)) {// 申请的审批(临时停车三级审批)
if (Utils.list.contains("getParkThirdApprove/updateStatus" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("getParkThirdApprove/updateStatus" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenParkThirdApproveController.updateStatus(result);
} else if ("getParkThirdApprove/getApplyInfo".equals(method)) {// 根据id和申请类型查询申请详情(临时停车三级审批)
if (Utils.list.contains("getParkThirdApprove/getApplyInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("getParkThirdApprove/getApplyInfo" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenParkThirdApproveController.getApplyInfo(result);
} else if ("greenParkThirdInfo/saveTempParkInfo".equals(method)) {// 保存临时停车申请信息(三级审批)
if (Utils.list.contains("greenParkThirdInfo/saveTempParkInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenParkThirdInfo/saveTempParkInfo" + checkTime);
}
GreenTempParkInfo greenTempParkInfo = (GreenTempParkInfo) JSONObject.toBean(data,
GreenTempParkInfo.class);
return greenParkThirdController.saveTempParkInfo(greenTempParkInfo);
} else if ("greenLogin/saveLog".equals(method)) {// 请求模块的日志
if (Utils.list.contains("greenLogin/saveLog" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenLogin/saveLog" + checkTime);
}
UserVo greenUserInfo = (UserVo) JSONObject.toBean(data, UserVo.class);
return greenLoginController.saveLog(greenUserInfo);
} else if ("evaluate/add".equals(method)) {// 添加评价
if (Utils.list.contains("evaluate/add" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("evaluate/add" + checkTime);
}
TorderEvaluate torderEvaluate = (TorderEvaluate) JSONObject.toBean(data, TorderEvaluate.class);
return evaluateController.add(torderEvaluate);
} else if ("evaluate/query".equals(method)) {// 查询评价
if (Utils.list.contains("evaluate/query" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("evaluate/query" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return evaluateController.query(map);
} else if ("feature/add".equals(method)) {// 推荐菜
if (Utils.list.contains("feature/add" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("feature/add" + checkTime);
}
GreenFoodFeature greenFoodFeature = (GreenFoodFeature) JSONObject.toBean(data, GreenFoodFeature.class);
return featureController.add(greenFoodFeature);
} else if ("feature/query".equals(method)) {// 查询推荐菜
if (Utils.list.contains("feature/query" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("feature/query" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return featureController.query(map);
} else if ("feature/queryMyFood".equals(method)) {// 查询推荐菜
if (Utils.list.contains("feature/queryMyFood" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("feature/queryMyFood" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return featureController.queryMyFood(map);
} else if ("feature/vote".equals(method)) {// 查询推荐菜
if (Utils.list.contains("feature/vote" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("feature/vote" + checkTime);
}
GreenFoodVote greenFoodVote = (GreenFoodVote) JSONObject.toBean(data, GreenFoodVote.class);
return featureController.vote(greenFoodVote);
} else if ("greenApply/getMyHaircutList".equals(method)) { // 获取理发预约
// 列表
if (Utils.list.contains("greenApply/getMyHaircutList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenApply/getMyHaircutList" + checkTime);
}
return greenApplyController.getMyHaircutList(data.getString("userId"), data.getInt("pageNum"),
data.getInt("pageSize"));
} else if ("greenApply/getMyHitchList".equals(method)) { // 获取理发预约
// 列表
if (Utils.list.contains("greenApply/getMyHitchList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenApply/getMyHitchList" + checkTime);
}
return greenApplyController.getMyHitchList(data.getString("userId"), data.getInt("pageNum"),
data.getInt("pageSize"));
} else if ("greenSpanRegisterInfo/submitRegister".equals(method)) {// 提交订单
if (Utils.list.contains("greenSpanRegisterInfo/submitRegister" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSpanRegisterInfo/submitRegister" + checkTime);
}
GreenSpanRegister greenSpanRegister = (GreenSpanRegister) JSONObject.toBean(data,
GreenSpanRegister.class);
return greenSpanRegisterController.submitRegister(greenSpanRegister);
} else if ("greenSpanRegisterInfo/query".equals(method)) {// 查询就餐登记列表
if (Utils.list.contains("greenSpanRegisterInfo/query" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSpanRegisterInfo/query" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenSpanRegisterController.query(map);
} else if ("greenApply/getDoHitchList".equals(method)) {//
if (Utils.list.contains("greenApply/getDoHitchList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenApply/getDoHitchList" + checkTime);
}
return greenApplyController.getDoHitchList(data.getString("userId"), data.getInt("pageNum"),
data.getInt("pageSize"));
} else if ("greenApply/getDisposeList".equals(method)) {//
if (Utils.list.contains("greenApply/getDisposeList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenApply/getDisposeList" + checkTime);
}
return greenApplyController.getDisposeList(data.getString("userId"), data.getInt("pageNum"),
data.getInt("pageSize"));
} else if ("greenApply/dispose".equals(method)) {//
if (Utils.list.contains("greenApply/dispose" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenApply/dispose" + checkTime);
}
return greenApplyController.dispose(data.getString("userId"), data.getLong("id"));
} else if ("greenApply/doHitch".equals(method)) {//
if (Utils.list.contains("greenApply/doHitch" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenApply/doHitch" + checkTime);
}
return greenApplyController.hitch(data.getString("userId"), data.getInt("type"), data.getLong("id"),
data.getString("personId"));
}
// 微信服务号
else if ("wechat/wechatOAuth".equals(method)) {// 微信授权功能
if (Utils.list.contains("wechat/saveWechatUser" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("wechat/wechatOAuth" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return wechatController.wechatOAuth(map);
}
// 微信用户注册
else if ("wechat/saveWechatUser".equals(method)) {// 更新用户
if (Utils.list.contains("wechat/saveWechatUser" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("wechat/saveWechatUser" + checkTime);
}
String vCode = data.getString("vCode");
String codeKey = data.getString("codeKey");
data.put("face_Pic1", "");
data.put("face_Pic1_Data", "");
data.put("identityAuth", "");
data.put("id_card", "");
data.put("role", "");
Map<String, Object> res = Utils.map.get(codeKey);
if (res == null) {
Utils.map.remove(codeKey);
return new RestResult(Constant.FAILED, "验证码错误!");
}
String mapCode = (String) res.get("code");
Long mapTime = (Long) res.get("time");
Long reqTime = Long.parseLong(checkTime);
Long diffTime = reqTime - mapTime;
// if(diffTime>60*1000*2){
// return new RestResult(Constant.FAILED, "验证码已失效,请重新获取!");
// }else{
// if(!mapCode.equals(vCode)){
// return new RestResult(Constant.FAILED, "验证码错误!");
// }
// }
if (!mapCode.equals(vCode)) {
Utils.map.remove(codeKey);
return new RestResult(Constant.FAILED, "验证码错误!");
}
GreenUserInfo greenUserInfo = (GreenUserInfo) JSONObject.toBean(data, GreenUserInfo.class);
return wechatController.saveWechatUser(greenUserInfo);
}
// 高校用户微信用户注册
else if ("wechat/saveWechatUserOfSchool".equals(method)) {// 更新用户
if (Utils.list.contains("wechat/saveWechatUserOfSchool" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("wechat/saveWechatUserOfSchool" + checkTime);
}
String vCode = data.getString("vCode");
String codeKey = data.getString("codeKey");
data.put("face_Pic1", "");
data.put("face_Pic1_Data", "");
data.put("identityAuth", "");
data.put("id_card", "");
Map<String, Object> res = Utils.map.get(codeKey);
if (res == null) {
Utils.map.remove(codeKey);
return new RestResult(Constant.FAILED, "验证码错误!");
}
String mapCode = (String) res.get("code");
Long mapTime = (Long) res.get("time");
Long reqTime = Long.parseLong(checkTime);
Long diffTime = reqTime - mapTime;
// if(diffTime>60*1000*2){
// return new RestResult(Constant.FAILED, "验证码已失效,请重新获取!");
// }else{
// if(!mapCode.equals(vCode)){
// return new RestResult(Constant.FAILED, "验证码错误!");
// }
// }
if (!mapCode.equals(vCode)) {
Utils.map.remove(codeKey);
return new RestResult(Constant.FAILED, "验证码错误!");
}
GreenUserInfo greenUserInfo = (GreenUserInfo) JSONObject.toBean(data, GreenUserInfo.class);
return wechatController.saveWechatUserOfSchool(greenUserInfo);
}
// 根据openid获取用户信息
else if ("greenUserInfo/getUserInfoByOpenId".equals(method)) {
if (Utils.list.contains("greenUserInfo/getUserInfoByOpenId" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUserInfo/getUserInfoByOpenId" + checkTime);
}
GreenUserInfo greenUserInfo = (GreenUserInfo) JSONObject.toBean(data, GreenUserInfo.class);
return greenUserInfoController.getUserInfoByOpenId(greenUserInfo);
} else if ("greenWashCar/initWashCar".equals(method)) {// 初始化某天洗车预约信息
if (Utils.list.contains("greenWashCar/initWashCar" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWashCar/initWashCar" + checkTime);
}
return greenWashCarController.initWashCar(
data.getString("applyPlace") == null ? "" : data.getString("applyPlace"),
data.getString("applyDate"), data.getString("userId"));
} else if ("greenWashCar/getPlaceData".equals(method)) {// 初始化某天洗车预约信息
if (Utils.list.contains("greenWashCar/getPlaceData" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWashCar/getPlaceData" + checkTime);
}
return greenWashCarController.getPlaceData(data.getString("userId"));
} else if ("greenWashCar/applyWashCar".equals(method)) {// 洗车预约
if (Utils.list.contains("greenWashCar/applyWashCar" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWashCar/applyWashCar" + checkTime);
}
GreenWashCarInfo info = (GreenWashCarInfo) JSONObject.toBean(data, GreenWashCarInfo.class);
return greenWashCarController.applyWashCar(info);
} else if ("greenWashCar/getWashInfoByDate".equals(method)) {// 洗车预约
if (Utils.list.contains("greenWashCar/getWashInfoByDate" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWashCar/getWashInfoByDate" + checkTime);
}
GreenWashCarInfo info = (GreenWashCarInfo) JSONObject.toBean(data, GreenWashCarInfo.class);
return greenWashCarController.getWashInfoByDate(info);
} else if ("greenWashCar/remindPickUpCar".equals(method)) {// 洗车预约
if (Utils.list.contains("greenWashCar/remindPickUpCar" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWashCar/remindPickUpCar" + checkTime);
}
GreenWashCarInfo info = (GreenWashCarInfo) JSONObject.toBean(data, GreenWashCarInfo.class);
return greenWashCarController.remindPickUpCar(info);
} else if ("greenWashCar/cancleWashCar".equals(method)) {// 洗车预约
if (Utils.list.contains("greenWashCar/cancleWashCar" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWashCar/cancleWashCar" + checkTime);
}
GreenWashCarInfo info = (GreenWashCarInfo) JSONObject.toBean(data, GreenWashCarInfo.class);
return greenWashCarController.cancleWashCar(info);
} else if ("greenWashCar/getCarsById".equals(method)) {// 获取当前登录人已有车辆 ccw
if (Utils.list.contains("greenWashCar/getCarsById" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWashCar/getCarsById" + checkTime);
}
GreenWashCarInfo info = (GreenWashCarInfo) JSONObject.toBean(data, GreenWashCarInfo.class);
return greenWashCarController.getCarsById(info);
}else if ("home/info".equals(method)) { // 首页查询
if (Utils.list.contains("home/info" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("home/info" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return HomeController.info(map);
} else if ("greenApply/getMyWashCarList".equals(method)) {
if (Utils.list.contains("greenApply/getMyWashCarList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenApply/getMyWashCarList" + checkTime);
}
return greenApplyController.getMyWashCarList(data.getString("userId"), data.getInt("pageNum"),
data.getInt("pageSize"));
} else if ("greenApply/getDoWashCarList".equals(method)) {
if (Utils.list.contains("greenApply/getDoWashCarList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenApply/getDoWashCarList" + checkTime);
}
return greenApplyController.getDoWashCarList(data.getString("userId"), data.getString("applyDate"),
data.getInt("pageNum"), data.getInt("pageSize"));
} else if ("greenGrantAuth/iOpenidGetUserInfo".equals(method)) { // 首页查询
if (Utils.list.contains("greenGrantAuth/iOpenidGetUserInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenGrantAuth/iOpenidGetUserInfo" + checkTime);
}
GreenUserInfo greenUserInfo = (GreenUserInfo) JSONObject.toBean(data, GreenUserInfo.class);
return greenGrantAuthController.iOpenidGetUserInfo(greenUserInfo);
} else if ("wechat/getCodeInfo".equals(method)) { // 获取短信验证码
if (Utils.list.contains("wechat/getCodeInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("wechat/getCodeInfo" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
map.put("checkTime", checkTime);
return wechatController.getCodeInfo(map);
}
/**
* 查询抽奖食品
*/
else if ("lottery/query".equals(method)) {
if (Utils.list.contains("lottery/query" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("lottery/query" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return lotteryController.query(map);
} else if ("lottery/add".equals(method)) {
if (Utils.list.contains("lottery/add" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("lottery/add" + checkTime);
}
GreenFoodLottery lottery = (GreenFoodLottery) JSONObject.toBean(data, GreenFoodLottery.class);
return lotteryController.add(lottery);
} else if ("greenFaultRepairInfo/queryPerson".equals(method)) {
if (Utils.list.contains("greenFaultRepairInfo/queryPerson" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/queryPerson" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenFaultRepairInfoController.queryPerson(map);
} else if ("greenUserInfo/getUserPers".equals(method)) {
if (Utils.list.contains("greenUserInfo/getUserPers" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUserInfo/getUserPers" + checkTime);
}
String userIdString = data.getString("userId");
String deptId = data.getString("deptId");
return greenUserInfoController.getUserPermission(userIdString, deptId);
} else if ("infoGrather/insertInfoGrather".equals(method)) {
if (Utils.list.contains("infoGrather/insertInfoGrather" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");// 新增人员信息
} else {
Utils.list.add("infoGrather/insertInfoGrather" + checkTime);
}
GreenInfoGrather infoGrather = (GreenInfoGrather) JSONObject.toBean(data, GreenInfoGrather.class);
return greenInfoGratherController.insertPepMessige(infoGrather);
} else if ("infoGrather/queryOne".equals(method)) {
if (Utils.list.contains("infoGrather/queryOne" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("infoGrather/queryOne" + checkTime);
}
GreenInfoGrather infoGrather = (GreenInfoGrather) JSONObject.toBean(data, GreenInfoGrather.class);
return greenInfoGratherController.queryOne(infoGrather);
} else if ("wechat/getOrgname".equals(method)) {
if (Utils.list.contains("wechat/getOrgname" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("wechat/getOrgname" + checkTime);
}
return wechatController.getOrgname();
} else if ("cameraManager/add".equals(method)) {
if (Utils.list.contains("cameraManager/add" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("cameraManager/add" + checkTime);
}
return cameraManagerController.add(data);
} else if ("cameraManager/query".equals(method)) {
if (Utils.list.contains("cameraManager/query" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("cameraManager/query" + checkTime);
}
return cameraManagerController.query(data);
} else if ("greenVisitorStatistics/getVisitorStatistics".equals(method)) {
if (Utils.list.contains("greenVisitorStatistics/getVisitorStatistics" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorStatistics/getVisitorStatistics" + checkTime);
}
return greenVisitorStatisticsController.getVisitorStatistics(data.getString("startDate"),
data.getString("endDate"), data.getString("userId"));
} else if ("greenVisitorStatistics/getVisitorStatisticsDetailed".equals(method)) {
if (Utils.list.contains("greenVisitorStatistics/getVisitorStatisticsDetailed" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorStatistics/getVisitorStatisticsDetailed" + checkTime);
}
return greenVisitorStatisticsController.getVisitorStatisticsDetailed(data.getString("startDate"),
data.getString("endDate"), data.getString("dep"), data.getString("type"),
data.getString("page"), data.getString("userId"));
} else if ("greenSysSetting/setSetting".equals(method)) {
if (Utils.list.contains("greenSysSetting/setSetting" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSysSetting/setSetting" + checkTime);
}
return greenSysSettingController.setSetting(data.getString("type"), data.getString("code"));
} else if ("greenSysSetting/getSetting".equals(method)) {
if (Utils.list.contains("greenSysSetting/setSgetSettingetting" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSysSetting/getSetting" + checkTime);
}
return greenSysSettingController.getSetting();
} else if ("greenVisitorStatistics/getInsideList".equals(method)) {
if (Utils.list.contains("greenVisitorStatistics/getInsideList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitorStatistics/getInsideList" + checkTime);
}
return greenVisitorStatisticsController.getInsideList(data.getString("startDate"),
data.getString("endDate"), data.getString("dep"), data.getString("page"),
data.getString("userId"));
} else if ("eAccount/getEAccount".equals(method)) {
if (Utils.list.contains("eAccount/getEAccount" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("eAccount/getEAccount" + checkTime);
}
return eaController.getEAccount(data.getString("userId"));
} else if ("eAccount/saveOrUpdate".equals(method)) {
if (Utils.list.contains("eAccount/saveOrUpdate" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("eAccount/saveOrUpdate" + checkTime);
}
GreenEAccount eAccount = (GreenEAccount) JSONObject.toBean(data, GreenEAccount.class);
return eaController.saveOrUpdate(eAccount);
} else if ("greenLicenseplateApproval/getLpaList".equals(method)) {
if (Utils.list.contains("greenLicenseplateApproval/getLpaList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenLicenseplateApproval/getLpaList" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenLicenseplateApprovalController.getLpaList(result);
} else if ("greenLicenseplateApproval/updatelicenseplateApprovalBatch".equals(method)) {
if (Utils.list.contains("greenLicenseplateApproval/updatelicenseplateApprovalBatch" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenLicenseplateApproval/updatelicenseplateApprovalBatch" + checkTime);
}
JSONArray dataArr = data.getJSONArray("list");
try {
for (int i = 0; i < dataArr.size(); i++) {
JSONObject jb = dataArr.getJSONObject(i);
GreenLicenseplateApproval greenLicenseplateApproval = (GreenLicenseplateApproval) JSONObject
.toBean(jb, GreenLicenseplateApproval.class);
greenLicenseplateApprovalController.updatelicenseplateApproval(greenLicenseplateApproval);
}
return new RestResult(Constant.SUCCESS, "操作成功!");
} catch (Exception e) {
e.printStackTrace();
return new RestResult(Constant.FAILED, "处理失败");
}
// return
// greenVisitorInfoController.updateVisitorInfoBatch(result);
} else if ("greenParkInfo/getMyParkInfoList".equals(method)) {
if (Utils.list.contains("greenParkInfo/getMyParkInfoList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenParkInfo/getMyParkInfoList" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenParkInfoController.getMyParkInfoList(result);
} else if ("greenParkInfo/saveDelayParkInfo".equals(method)) {
if (Utils.list.contains("greenParkInfo/saveDelayParkInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenParkInfo/saveDelayParkInfo" + checkTime);
}
GreenParkInfo result = (GreenParkInfo) JSONObject.toBean(data, GreenParkInfo.class);
return greenParkInfoController.saveDelayParkInfo(result);
} else if ("greenParkInfo/getParkInfoApprovalList".equals(method)) {
if (Utils.list.contains("greenParkInfo/getParkInfoApprovalList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenParkInfo/getParkInfoApprovalList" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenParkInfoController.getParkInfoApprovalList(result);
} else if ("greenParkInfo/updateParkInfoApprovalBatch".equals(method)) {// 查询我的预约申请列表和我的邀约列表
if (Utils.list.contains("greenParkInfo/updateParkInfoApprovalBatch" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenParkInfo/updateParkInfoApprovalBatch" + checkTime);
}
JSONArray dataArr = data.getJSONArray("list");
try {
for (int i = 0; i < dataArr.size(); i++) {
JSONObject jb = dataArr.getJSONObject(i);
Result result = (Result) JSONObject.toBean(jb, Result.class);
greenParkInfoController.updateParkInfoApprovalBatch(result);
}
return new RestResult(Constant.SUCCESS, "操作成功!");
} catch (Exception e) {
e.printStackTrace();
return new RestResult(Constant.FAILED, "处理失败");
}
// return
// greenVisitorInfoController.updateVisitorInfoBatch(result);
} else if ("greenParkRecord/getParkRecordList".equals(method)) {
if (Utils.list.contains("greenParkRecord/getParkRecordList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenParkRecord/getParkRecordList" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenParkRecordController.getParkRecordList(result);
} else if ("greenParkRecord/getParkRecordCount".equals(method)) {
if (Utils.list.contains("greenParkRecord/getParkRecordCount" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenParkRecord/getParkRecordCount" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenParkRecordController.getParkRecordCount(result);
} else if ("greenEnterprise/getEnterpriseNames".equals(method)) {
if (Utils.list.contains("greenEnterprise/getEnterpriseNames" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEnterprise/getEnterpriseNames" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEnterpriseController.getEnterpriseNames(map);
} else if ("greenMyHealthy/saveMyHealthy".equals(method)) {
if (Utils.list.contains("greenMyHealthy/saveMyHealthy" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMyHealthy/saveMyHealthy" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenMyHealthyController.saveMyHealthy(map);
} else if ("greenMyHealthy/getHealthyList".equals(method)) {
if (Utils.list.contains("greenMyHealthy/getHealthyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMyHealthy/getHealthyList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenMyHealthyController.getHealthyList(map);
}
else if ("greenMyHealthy/getMyHealthyStatistics".equals(method)) {
if (Utils.list.contains("greenMyHealthy/getMyHealthyStatistics" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMyHealthy/getMyHealthyStatistics" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenMyHealthyController.getMyHealthyStatistics(data.getString("startDate"),
data.getString("endDate"), data.getString("userId"));
}
else if ("greenMyHealthy/getMyHealthyDetailed".equals(method)) {
if (Utils.list.contains("greenMyHealthy/getMyHealthyDetailed" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMyHealthy/getMyHealthyDetailed" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenMyHealthyController.getMyHealthyDetailed(data.getString("startDate"),
data.getString("endDate"), data.getString("dep"), data.getString("page"),
data.getString("userId"), data.getString("type"));
} else if ("greenDepartment/getAllCompany".equals(method)) {
if (Utils.list.contains("greenDepartment/getAllCompany" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDepartment/getAllCompany" + checkTime);
}
return greenDepartmentController.getAllCompany();
} else if ("greenDepartment/getAllDeptOfCompany".equals(method)) {
if (Utils.list.contains("greenDepartment/getAllDeptOfCompany" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDepartment/getAllDeptOfCompany" + checkTime);
}
return greenDepartmentController.getAllDeptOfCompany(data);
} else if ("greenDrugsApply/submitDrugsApply".equals(method)) {
if (Utils.list.contains("greenDrugsApply/submitDrugsApply" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsApply/submitDrugsApply" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
mapClass.put("detailList", GreenDrugsDetail.class);
GreenDrugsApply result = (GreenDrugsApply) JSONObject.toBean(data, GreenDrugsApply.class, mapClass);
// GreenDrugsApply result = (GreenDrugsApply)
// JSONObject.toBean(data,GreenDrugsApply.class);
return greenDrugsApplyController.submitDrugsApply(result);
} else if ("greenDrugsApply/getMyDrugsApplyList".equals(method)) {
if (Utils.list.contains("greenDrugsApply/getMyDrugsApplyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsApply/getMyDrugsApplyList" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
mapClass.put("detailList", GreenDrugsDetail.class);
GreenDrugsApply result = (GreenDrugsApply) JSONObject.toBean(data, GreenDrugsApply.class, mapClass);
// GreenDrugsApply result = (GreenDrugsApply)
// JSONObject.toBean(data,GreenDrugsApply.class);
return greenDrugsApplyController.getMyDrugsApplyList(result);
} else if ("greenDrugsApply/getDrugsApplyList".equals(method)) {
if (Utils.list.contains("greenDrugsApply/getDrugsApplyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsApply/getDrugsApplyList" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
mapClass.put("detailList", GreenDrugsDetail.class);
GreenDrugsApply result = (GreenDrugsApply) JSONObject.toBean(data, GreenDrugsApply.class, mapClass);
// GreenDrugsApply result = (GreenDrugsApply)
// JSONObject.toBean(data,GreenDrugsApply.class);
return greenDrugsApplyController.getDrugsApplyList(result);
} else if ("greenDrugsApply/getDrugsApplyDetail".equals(method)) {
if (Utils.list.contains("greenDrugsApply/getDrugsApplyDetail" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsApply/getDrugsApplyDetail" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
mapClass.put("detailList", GreenDrugsDetail.class);
GreenDrugsApply result = (GreenDrugsApply) JSONObject.toBean(data, GreenDrugsApply.class, mapClass);
// GreenDrugsApply result = (GreenDrugsApply)
// JSONObject.toBean(data,GreenDrugsApply.class);
return greenDrugsApplyController.getDrugsApplyDetail(result);
} else if ("greenDrugsApply/updateDrugs".equals(method)) {
if (Utils.list.contains("greenDrugsApply/updateDrugs" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsApply/updateDrugs" + checkTime);
}
// Map<String, Class> mapClass = new HashMap<String, Class>();
// mapClass.put("detailList", GreenDrugsDetail.class);
// GreenDrugsApply result = (GreenDrugsApply)
// JSONObject.toBean(data,
// GreenDrugsApply.class, mapClass);
return greenDrugsApplyController.updateDrugs(data);
} else if ("greenDrugsApply/drugsApplyApproval".equals(method)) {
if (Utils.list.contains("greenDrugsApply/drugsApplyApproval" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsApply/drugsApplyApproval" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
mapClass.put("detailList", GreenDrugsDetail.class);
GreenDrugsApply result = (GreenDrugsApply) JSONObject.toBean(data, GreenDrugsApply.class, mapClass);
return greenDrugsApplyController.drugsApplyApproval(result);
} else if ("greenDrugsApply/remindPickUpDrugs".equals(method)) {
if (Utils.list.contains("greenDrugsApply/remindPickUpDrugs" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsApply/remindPickUpDrugs" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
mapClass.put("detailList", GreenDrugsDetail.class);
GreenDrugsApply result = (GreenDrugsApply) JSONObject.toBean(data, GreenDrugsApply.class, mapClass);
return greenDrugsApplyController.remindPickUpDrugs(result);
} else if ("greenUsecarApply/submitUseCarApply".equals(method)) {
if (Utils.list.contains("greenUsecarApply/submitUseCarApply" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUsecarApply/submitUseCarApply" + checkTime);
}
GreenUsecarApply result = (GreenUsecarApply) JSONObject.toBean(data, GreenUsecarApply.class);
return greenUseCarApplyController.submitUseCarApply(result);
} else if ("greenUsecarApply/getMyUsecarApplyList".equals(method)) {
if (Utils.list.contains("greenUsecarApply/getMyUsecarApplyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUsecarApply/getMyUsecarApplyList" + checkTime);
}
GreenUsecarApply result = (GreenUsecarApply) JSONObject.toBean(data, GreenUsecarApply.class);
return greenUseCarApplyController.getMyUsecarApplyList(result);
} else if ("greenUsecarApply/getUsecarApplyList".equals(method)) {
if (Utils.list.contains("greenUsecarApply/getUsecarApplyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUsecarApply/getUsecarApplyList" + checkTime);
}
GreenUsecarApply result = (GreenUsecarApply) JSONObject.toBean(data, GreenUsecarApply.class);
return greenUseCarApplyController.getUsecarApplyList(result);
} else if ("greenUsecarApply/getDriverList".equals(method)) {
if (Utils.list.contains("greenUsecarApply/getDriverList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUsecarApply/getDriverList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenUseCarApplyController.getDriverList(map);
} else if ("greenUsecarApply/acceptUseCarApply".equals(method)) {
if (Utils.list.contains("greenUsecarApply/acceptUseCarApply" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUsecarApply/acceptUseCarApply" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenUseCarApplyController.acceptUseCarApply(map);
} else if ("greenUsecarApply/finishUseCar".equals(method)) {
if (Utils.list.contains("greenUsecarApply/finishUseCar" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUsecarApply/finishUseCar" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenUseCarApplyController.finishUseCar(map);
} else if ("greenUsecarApply/approvalUseCarApply".equals(method)) {
if (Utils.list.contains("greenUsecarApply/approvalUseCarApply" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUsecarApply/approvalUseCarApply" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenUseCarApplyController.approvalUseCarApply(map);
} else if ("greenCatagory/getCatagoryList".equals(method)) {
if (Utils.list.contains("greenCatagory/getCatagoryList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCatagory/getCatagoryList" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
return greenCatagoryController.getCatagoryList(mapClass);
} else if ("greenCatagory/getAllProdunctions".equals(method)) {
if (Utils.list.contains("greenCatagory/getAllProdunctions" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCatagory/getAllProdunctions" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
return greenCatagoryController.getAllProdunctions(mapClass);
} else if ("greenCatagory/getChoosedProdunctions".equals(method)) {
if (Utils.list.contains("greenCatagory/getChoosedProdunctions" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCatagory/getChoosedProdunctions" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenCatagoryController.getChoosedProdunctions(map);
} else if ("greenCatagory/getProductionList".equals(method)) {
if (Utils.list.contains("greenCatagory/getProductionList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCatagory/getProductionList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenCatagoryController.getProductionList(map);
}
else if ("greenCatagory/saveMyProductionApply".equals(method)) {
if (Utils.list.contains("greenCatagory/saveMyProductionApply" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCatagory/saveMyProductionApply" + checkTime);
}
Map<String, Class> mapClass = (Map<String, Class>) JSONObject.toBean(data, Map.class);
return greenCatagoryController.saveMyProductionApply(mapClass);
}
else if ("greenDepartment/getAllSchool".equals(method)) {
if (Utils.list.contains("greenDepartment/getAllSchool" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDepartment/getAllSchool" + checkTime);
}
return greenDepartmentController.getAllSchool();
} else if ("greenDepartment/getAllFacultyBySchool".equals(method)) {
if (Utils.list.contains("greenDepartment/getAllFacultyBySchool" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDepartment/getAllFacultyBySchool" + checkTime);
}
return greenDepartmentController.getAllFacultyBySchool(data);
} else if ("greenDepartment/getAllClassByFaculty".equals(method)) {
if (Utils.list.contains("greenDepartment/getAllClassByFaculty" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDepartment/getAllClassByFaculty" + checkTime);
}
return greenDepartmentController.getAllClassByFaculty(data);
} else if ("exam/getExamList".equals(method)) {
if (Utils.list.contains("exam/getExamList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("exam/getExamList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenExamController.getExamList(map);
} else if ("exam/getMyExamAnswerList".equals(method)) {
if (Utils.list.contains("exam/getMyExamAnswerList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("exam/getMyExamAnswerList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenExamController.getMyExamAnswerList(map);
} else if ("exam/getExamDetail".equals(method)) {
if (Utils.list.contains("exam/getExamDetail" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("exam/getExamDetail" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenExamController.getExamDetail(map);
} else if ("exam/saveExam".equals(method)) {
if (Utils.list.contains("exam/saveExam" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("exam/saveExam" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenExamController.saveExam(map);
} else if ("greenSeekMedicalRecord/getSeekmedicalProject".equals(method)) {
if (Utils.list.contains("greenSeekMedicalRecord/getSeekmedicalProject" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSeekMedicalRecord/getSeekmedicalProject" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenSeekmedicalRecordController.getSeekmedicalProject(map);
} else if ("greenSeekMedicalRecord/getSeekmedicalProjectSl".equals(method)) {
if (Utils.list.contains("greenSeekMedicalRecord/getSeekmedicalProjectSl" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSeekMedicalRecord/getSeekmedicalProjectSl" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenSeekmedicalRecordController.getSeekmedicalProjectSl(map);
} else if ("greenSeekMedicalRecord/getSeekmedicalProjectInfo".equals(method)) {
if (Utils.list.contains("greenSeekMedicalRecord/getSeekmedicalProjectInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSeekMedicalRecord/getSeekmedicalProjectInfo" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenSeekmedicalRecordController.getSeekmedicalProjectInfo(map);
} else if ("greenSeekMedicalRecord/saveSeekmedicalProjectRecord".equals(method)) {
if (Utils.list.contains("greenSeekMedicalRecord/saveSeekmedicalProjectRecord" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSeekMedicalRecord/saveSeekmedicalProjectRecord" + checkTime);
}
GreenSeekmedicalRecord result = (GreenSeekmedicalRecord) JSONObject.toBean(data,
GreenSeekmedicalRecord.class);
return greenSeekmedicalRecordController.saveSeekmedicalProjectRecord(result);
} else if ("greenSeekMedicalRecord/getMySeekmedicalProjectRecord".equals(method)) {
if (Utils.list.contains("greenSeekMedicalRecord/getMySeekmedicalProjectRecord" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSeekMedicalRecord/getMySeekmedicalProjectRecord" + checkTime);
}
GreenSeekmedicalRecord result = (GreenSeekmedicalRecord) JSONObject.toBean(data,
GreenSeekmedicalRecord.class);
return greenSeekmedicalRecordController.getMySeekmedicalProjectRecord(result);
} else if ("greenSeekMedicalRecord/getSlSeekmedicalProjectRecord".equals(method)) {
if (Utils.list.contains("greenSeekMedicalRecord/getSlSeekmedicalProjectRecord" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSeekMedicalRecord/getSlSeekmedicalProjectRecord" + checkTime);
}
GreenSeekmedicalRecord result = (GreenSeekmedicalRecord) JSONObject.toBean(data,
GreenSeekmedicalRecord.class);
return greenSeekmedicalRecordController.getSlSeekmedicalProjectRecord(result);
} else if ("greenFaultRepairInfo/getMyFaultRepairList".equals(method)) {
if (Utils.list.contains("greenFaultRepairInfo/getMyFaultRepairList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/getMyFaultRepairList" + checkTime);
}
GreenFaultRepairInfo result = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.getMyFaultRepairList(result);
} else if ("greenFaultRepairInfo/getSlFaultRepairList".equals(method)) {
if (Utils.list.contains("greenFaultRepairInfo/getSlFaultRepairList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/getSlFaultRepairList" + checkTime);
}
GreenFaultRepairInfo result = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.getSlFaultRepairList(result);
} else if ("greenFaultRepairInfo/chooseClPreson".equals(method)) {
if (Utils.list.contains("greenFaultRepairInfo/chooseClPreson" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/chooseClPreson" + checkTime);
}
GreenFaultRepairInfo result = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.chooseClPreson(result);
} else if ("greenFaultRepairInfo/getClFaultRepairList".equals(method)) {
if (Utils.list.contains("greenFaultRepairInfo/getClFaultRepairList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/getClFaultRepairList" + checkTime);
}
GreenFaultRepairInfo result = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.getClFaultRepairList(result);
} else if ("greenFaultRepairInfo/submitFinish".equals(method)) {
if (Utils.list.contains("greenFaultRepairInfo/submitFinish" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/submitFinish" + checkTime);
}
GreenFaultRepairInfo result = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.submitFinish(result);
} else if ("greenFaultRepairInfo/submitUrgent".equals(method)) {
if (Utils.list.contains("greenFaultRepairInfo/submitUrgent" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/submitUrgent" + checkTime);
}
GreenFaultRepairInfo result = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.submitUrgent(result);
} else if ("greenFaultRepairInfo/getFaultRepairByParentCode".equals(method)) {// 查询我的申请列表和我的待办列表(临时停车三级审批)
if (Utils.list.contains("greenFaultRepairInfo/getFaultRepairByParentCode" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/getFaultRepairByParentCode" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenFaultRepairInfoController.getFaultRepairByParentCode(result);
} else if ("greenFaultRepairInfo/getFaultRepairAll".equals(method)) {// 查询我的申请列表和我的待办列表(临时停车三级审批)
if (Utils.list.contains("greenFaultRepairInfo/getFaultRepairAll" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/getFaultRepairAll" + checkTime);
}
Result result = (Result) JSONObject.toBean(data, Result.class);
return greenFaultRepairInfoController.getFaultRepairAll(result);
}
// 获取微信签名,微信权限
else if ("wechat/wechatJsSdk2".equals(method)) {
if (Utils.list.contains("wechat/wechatJsSdk2" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("wechat/wechatJsSdk2" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return wechatController.wechatJsSdk2(map);
}
else if ("feature/submitRecommendFood".equals(method)) {
if (Utils.list.contains("feature/submitRecommendFood" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("feature/submitRecommendFood" + checkTime);
}
GreenFoodFeature result = (GreenFoodFeature) JSONObject.toBean(data, GreenFoodFeature.class);
return featureController.submitRecommendFood(result);
} else if ("feature/getMySubmitFeatureFood".equals(method)) {
if (Utils.list.contains("feature/getMySubmitFeatureFood" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("feature/getMySubmitFeatureFood" + checkTime);
}
GreenFoodFeature result = (GreenFoodFeature) JSONObject.toBean(data, GreenFoodFeature.class);
return featureController.getMySubmitFeatureFood(result);
} else if ("feature/getPublicFeatureFood".equals(method)) {
if (Utils.list.contains("feature/getPublicFeatureFood" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("feature/getPublicFeatureFood" + checkTime);
}
GreenFoodFeature result = (GreenFoodFeature) JSONObject.toBean(data, GreenFoodFeature.class);
return featureController.getPublicFeatureFood(result);
} else if ("feature/recommendFoodVoteNew".equals(method)) {// 查询推荐菜
if (Utils.list.contains("feature/recommendFoodVoteNew" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("feature/recommendFoodVoteNew" + checkTime);
}
GreenFoodVote greenFoodVote = (GreenFoodVote) JSONObject.toBean(data, GreenFoodVote.class);
return featureController.recommendFoodVoteNew(greenFoodVote);
} else if ("feature/submitRelease".equals(method)) {
if (Utils.list.contains("feature/submitRelease" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("feature/submitRelease" + checkTime);
}
GreenFoodFeature result = (GreenFoodFeature) JSONObject.toBean(data, GreenFoodFeature.class);
return featureController.submitRelease(result);
} else if ("feature/getReleasefeatureList".equals(method)) {
if (Utils.list.contains("feature/getReleasefeatureList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("feature/getReleasefeatureList" + checkTime);
}
GreenFoodFeature result = (GreenFoodFeature) JSONObject.toBean(data, GreenFoodFeature.class);
return featureController.getReleasefeatureList(result);
} else if ("evaluate/getCommentListByType".equals(method)) {
if (Utils.list.contains("evaluate/getCommentListByType" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("evaluate/getCommentListByType" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return evaluateController.getCommentListByType(map);
} else if ("greenSeekMedicalRecord/cancelSeekmedicalRecord".equals(method)) {
if (Utils.list.contains("greenSeekMedicalRecord/cancelSeekmedicalRecord" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSeekMedicalRecord/cancelSeekmedicalRecord" + checkTime);
}
GreenSeekmedicalRecord result = (GreenSeekmedicalRecord) JSONObject.toBean(data,
GreenSeekmedicalRecord.class);
return greenSeekmedicalRecordController.cancelSeekmedicalRecord(result);
} else if ("greenCalendar/getCalendarList".equals(method)) {// 查询评价
if (Utils.list.contains("greenCalendar/getCalendarList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCalendar/getCalendarList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenCalendarController.getCalendarList(map);
} else if ("greenStatistics/getYuyueStatistics".equals(method)) {// 查询评价
if (Utils.list.contains("greenStatistics/getYuyueStatistics" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenStatistics/getYuyueStatistics" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenStatisticsController.getYuyueStatistics(map);
} else if ("greenHealthMsg/getHealthMsgType".equals(method)) {// 查询评价
if (Utils.list.contains("greenHealthMsg/getHealthMsgType" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHealthMsg/getHealthMsgType" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenHealthMsgController.getHealthMsgType(map);
} else if ("greenHealthMsg/getHealthMsgList".equals(method)) {
if (Utils.list.contains("greenHealthMsg/getHealthMsgList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHealthMsg/getHealthMsgList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenHealthMsgController.getHealthMsgList(map);
} else if ("greenHealthMsg/getHealthMsgDetail".equals(method)) {// 查询评价
if (Utils.list.contains("greenHealthMsg/getHealthMsgDetail" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHealthMsg/getHealthMsgDetail" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenHealthMsgController.getHealthMsgDetail(map);
} else if ("greenDrugsPush/submitDrugsPushAdd".equals(method)) {// 查询评价
if (Utils.list.contains("greenDrugsPush/submitDrugsPushAdd" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsPush/submitDrugsPushAdd" + checkTime);
}
GreenDrugsPush result = (GreenDrugsPush) JSONObject.toBean(data, GreenDrugsPush.class);
return greenDrugsPushController.submitDrugsPushAdd(result);
} else if ("greenDrugsPush/getReleaseDrugsList".equals(method)) {// 查询评价
if (Utils.list.contains("greenDrugsPush/getReleaseDrugsList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsPush/getReleaseDrugsList" + checkTime);
}
GreenDrugsPush result = (GreenDrugsPush) JSONObject.toBean(data, GreenDrugsPush.class);
return greenDrugsPushController.getReleaseDrugsList(result);
} else if ("greenDrugsPush/getPublicDrugsPush".equals(method)) {// 查询评价
if (Utils.list.contains("greenDrugsPush/getPublicDrugsPush" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsPush/getPublicDrugsPush" + checkTime);
}
GreenDrugsPush result = (GreenDrugsPush) JSONObject.toBean(data, GreenDrugsPush.class);
return greenDrugsPushController.getPublicDrugsPush(result);
} else if ("greenDrugsPush/getMySubmitDrugsPush".equals(method)) {// 查询评价
if (Utils.list.contains("greenDrugsPush/getMySubmitDrugsPush" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsPush/getMySubmitDrugsPush" + checkTime);
}
GreenDrugsPush result = (GreenDrugsPush) JSONObject.toBean(data, GreenDrugsPush.class);
return greenDrugsPushController.getMySubmitDrugsPush(result);
} else if ("greenDrugsPush/submitDrugsRelease".equals(method)) {// 查询评价
if (Utils.list.contains("greenDrugsPush/submitDrugsRelease" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsPush/submitDrugsRelease" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenDrugsPushController.submitDrugsRelease(map);
} else if ("greenDrugsPush/drugsPushVote".equals(method)) {// 查询评价
if (Utils.list.contains("greenDrugsPush/drugsPushVote" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDrugsPush/drugsPushVote" + checkTime);
}
GreenFoodVote vote = (GreenFoodVote) JSONObject.toBean(data, GreenFoodVote.class);
return greenDrugsPushController.drugsPushVote(vote);
} else if ("newsInfo/query".equals(method)) {
if (Utils.list.contains("newsInfo/query" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("newsInfo/query" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return newsInfoController.query(map);
} else if ("greenReport/addReport".equals(method)) {
if (Utils.list.contains("greenReport/addReport" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenReport/addReport" + checkTime);
}
GreenReport greenReport = (GreenReport) JSONObject.toBean(data, GreenReport.class);
return greenReportController.addReport(greenReport);
} else if ("greenReport/getReportList".equals(method)) {
if (Utils.list.contains("greenReport/getReportList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenReport/getReportList" + checkTime);
}
GreenReport greenReport = (GreenReport) JSONObject.toBean(data, GreenReport.class);
return greenReportController.getReportList(greenReport);
} else if ("greenReport/getReportCount".equals(method)) {
if (Utils.list.contains("greenReport/getReportCount" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenReport/getReportCount" + checkTime);
}
GreenReport greenReport = (GreenReport) JSONObject.toBean(data, GreenReport.class);
return greenReportController.getReportCount(greenReport);
} else if ("greenReport/queryReport".equals(method)) {
if (Utils.list.contains("greenReport/queryReport" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenReport/queryReport" + checkTime);
}
GreenReport greenReport = (GreenReport) JSONObject.toBean(data, GreenReport.class);
return greenReportController.queryReport(greenReport);
} else if ("greenReport/replyReport".equals(method)) {
if (Utils.list.contains("greenReport/replyReport" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenReport/replyReport" + checkTime);
}
GreenReport greenReport = (GreenReport) JSONObject.toBean(data, GreenReport.class);
return greenReportController.replyReport(greenReport);
} else if ("greenReport/finishReport".equals(method)) {
if (Utils.list.contains("greenReport/finishReport" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenReport/finishReport" + checkTime);
}
GreenReport greenReport = (GreenReport) JSONObject.toBean(data, GreenReport.class);
return greenReportController.finishReport(greenReport);
} else if ("greenActiveInfo/getActiveInfoList".equals(method)) {
if (Utils.list.contains("greenActiveInfo/getActiveInfoList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenActiveInfo/getActiveInfoList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenActiveInfoController.getActiveInfoList(map);
} else if ("greenActiveInfo/getActiveInfo".equals(method)) {
if (Utils.list.contains("greenActiveInfo/getActiveInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenActiveInfo/getActiveInfo" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenActiveInfoController.getActiveInfo(map);
} else if ("greenActiveInfo/signUpActive".equals(method)) {
if (Utils.list.contains("greenActiveInfo/signUpActive" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenActiveInfo/signUpActive" + checkTime);
}
GreenActiveSign greenActiveSign = (GreenActiveSign) JSONObject.toBean(data, GreenActiveSign.class);
return greenActiveInfoController.signUpActive(greenActiveSign);
} else if ("greenActiveInfo/signInActive".equals(method)) {
if (Utils.list.contains("greenActiveInfo/signInActive" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenActiveInfo/signInActive" + checkTime);
}
GreenActiveSign greenActiveSign = (GreenActiveSign) JSONObject.toBean(data, GreenActiveSign.class);
return greenActiveInfoController.signInActive(greenActiveSign);
} else if ("greenFaultRepairInfo/getFaultListByReply".equals(method)) {// 保存故障报修申请信息
if (Utils.list.contains("greenFaultRepairInfo/getFaultListByReply" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/getFaultListByReply" + checkTime);
}
GreenFaultRepairInfo greenFaultRepairInfo = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.getFaultListByReply(greenFaultRepairInfo);
} else if ("greenFaultRepairInfo/getFaultCountByReply".equals(method)) {// 保存故障报修申请信息
if (Utils.list.contains("greenFaultRepairInfo/getFaultCountByReply" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/getFaultCountByReply" + checkTime);
}
GreenFaultRepairInfo greenFaultRepairInfo = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.getFaultCountByReply(greenFaultRepairInfo);
} else if ("greenFaultRepairInfo/getFaultRepairInfoById".equals(method)) {// 保存故障报修申请信息
if (Utils.list.contains("greenFaultRepairInfo/getFaultRepairInfoById" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/getFaultRepairInfoById" + checkTime);
}
GreenFaultRepairInfo greenFaultRepairInfo = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.getFaultRepairInfoById(greenFaultRepairInfo);
} else if ("greenFaultRepairInfo/finishFault".equals(method)) {// 保存故障报修申请信息
if (Utils.list.contains("greenFaultRepairInfo/finishFault" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/finishFault" + checkTime);
}
GreenFaultRepairInfo greenFaultRepairInfo = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.finishFault(greenFaultRepairInfo);
} else if ("greenFaultRepairInfo/replyFaultRepairInfo".equals(method)) {// 保存故障报修申请信息
if (Utils.list.contains("greenFaultRepairInfo/replyFaultRepairInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/replyFaultRepairInfo" + checkTime);
}
GreenFaultRepairInfo greenFaultRepairInfo = (GreenFaultRepairInfo) JSONObject.toBean(data,
GreenFaultRepairInfo.class);
return greenFaultRepairInfoController.replyFaultRepairInfo(greenFaultRepairInfo);
} else if ("greenMealCard/initData".equals(method)) {
if (Utils.list.contains("greenMealCard/initData" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMealCard/initData" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenMealCardController.initData(map);
} else if ("greenDepartment/getDeptByParentId".equals(method)) {
if (Utils.list.contains("greenDepartment/getDeptByParentId" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenDepartment/getDeptByParentId" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenDepartmentController.getDeptByParentId(map);
} else if ("applogin/register".equals(method)) {// 保存故障报修申请信息
if (Utils.list.contains("applogin/register" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("applogin/register" + checkTime);
}
GreenUserInfo greenUserInfo = (GreenUserInfo) JSONObject.toBean(data, GreenUserInfo.class);
return appLoginController.register(greenUserInfo);
} else if ("applogin/login".equals(method)) {// 保存故障报修申请信息
if (Utils.list.contains("applogin/login" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("applogin/login" + checkTime);
}
GreenUserInfo greenUserInfo = (GreenUserInfo) JSONObject.toBean(data, GreenUserInfo.class);
return appLoginController.login(greenUserInfo, clientId);
} else if ("applogin/updateUserInfo".equals(method)) {// 保存故障报修申请信息
if (Utils.list.contains("applogin/updateUserInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("applogin/updateUserInfo" + checkTime);
}
GreenUserInfo greenUserInfo = (GreenUserInfo) JSONObject.toBean(data, GreenUserInfo.class);
return appLoginController.updateUserInfo(greenUserInfo);
} else if ("applogin/updatePwd".equals(method)) {
if (Utils.list.contains("applogin/updatePwd" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("applogin/updatePwd" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return appLoginController.updatePwd(map);
} else if ("applogin/getShopMallToken".equals(method)) {
if (Utils.list.contains("applogin/getShopMallToken" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("applogin/getShopMallToken" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return appLoginController.getShopMallToken(map, response, request);
} else if ("appupdate/getAppUpdateInfo".equals(method)) {
if (Utils.list.contains("appupdate/getAppUpdateInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("appupdate/getAppUpdateInfo" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return appUpdateController.getAppUpdateInfo(map);
} else if ("greenApply/getAllHaircutList".equals(method)) {
if (Utils.list.contains("greenApply/getAllHaircutList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenApply/getAllHaircutList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenApplyController.getAllHaircutList(map);
} else if ("greenApply/getAllWashCarList".equals(method)) {
if (Utils.list.contains("greenApply/getAllWashCarList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenApply/getAllWashCarList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenApplyController.getAllWashCarList(map);
} else if ("greenSeekMedicalRecord/getAllSeekmedicalProjectRecord".equals(method)) {
if (Utils.list.contains("greenSeekMedicalRecord/getAllSeekmedicalProjectRecord" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenSeekMedicalRecord/getAllSeekmedicalProjectRecord" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenSeekmedicalRecordController.getAllSeekmedicalProjectRecord(map);
} else if ("greenProblemCollect/save".equals(method)) {// 保存故障报修申请信息
if (Utils.list.contains("greenProblemCollect/save" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenProblemCollect/save" + checkTime);
}
GreenProblemCollect greenProblemCollect = (GreenProblemCollect) JSONObject.toBean(data,
GreenProblemCollect.class);
return greenProblemCollectController.save(greenProblemCollect);
} else if ("greenNotice/getMyNoticeList".equals(method)) {
if (Utils.list.contains("greenNotice/getMyNoticeList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenNotice/getMyNoticeList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenNoticeController.getMyNoticeList(map);
} else if ("greenNotice/updateNoticeRead".equals(method)) {
if (Utils.list.contains("greenNotice/updateNoticeRead" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenNotice/updateNoticeRead" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenNoticeController.updateNoticeRead(map);
} else if ("greenNotice/getUnReadNum".equals(method)) {
if (Utils.list.contains("greenNotice/getUnReadNum" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenNotice/getUnReadNum" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenNoticeController.getUnReadNum(map);
} else if ("greenNotice/clearNoticeData".equals(method)) {
if (Utils.list.contains("greenNotice/clearNoticeData" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenNotice/clearNoticeData" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenNoticeController.clearNoticeData(map);
} else if ("greenFoodOrderDetail/getAllFoodList".equals(method)) {
if (Utils.list.contains("greenFoodOrderDetail/getAllFoodList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodOrderDetail/getAllFoodList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenFoodOrderDetailController.getAllFoodList(map);
} else if ("greenFaultRepairInfo/getDeviceList".equals(method)) {
if (Utils.list.contains("greenFaultRepairInfo/getDeviceList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/getDeviceList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenFaultRepairInfoController.getDeviceList(map);
} else if ("greenMarket/getMarketKindsList".equals(method)) {
if (Utils.list.contains("greenMarket/getMarketKindsList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMarket/getMarketKindsList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenMarketController.getMarketKindsList(map);
} else if ("greenMarket/getAttrTypes".equals(method)) {
if (Utils.list.contains("greenMarket/getAttrTypes" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMarket/getAttrTypes" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenMarketController.getAttrTypes(map);
} else if ("greenMarket/submitMarketOrder".equals(method)) {// 提交订单
if (Utils.list.contains("greenMarket/submitMarketOrder" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMarket/submitMarketOrder" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
mapClass.put("orderDetails", GreenFoodOrderDetailDTO.class);
GreenFoodOrderListDTO greenfoodorderlists = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapClass);
return greenMarketController.submitMarketOrder(greenfoodorderlists);
} else if ("greenMarket/myMarketOrderList".equals(method)) {// 我的订单列表
if (Utils.list.contains("greenMarket/myMarketOrderList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMarket/myMarketOrderList" + checkTime);
}
Map<String, Class> mapOrderListClass = new HashMap<String, Class>();
mapOrderListClass.put("orderDetails", GreenFoodOrderDetail.class);
GreenFoodOrderListDTO greenFoodOrderListDTO = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapOrderListClass);
return greenMarketController.myMarketOrderList(greenFoodOrderListDTO);
} else if ("greenMarket/marketOrderList".equals(method)) {// 我的订单列表
if (Utils.list.contains("greenMarket/marketOrderList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMarket/marketOrderList" + checkTime);
}
Map<String, Class> mapOrderListClass = new HashMap<String, Class>();
mapOrderListClass.put("orderDetails", GreenFoodOrderDetail.class);
GreenFoodOrderListDTO greenFoodOrderListDTO = (GreenFoodOrderListDTO) JSONObject.toBean(data,
GreenFoodOrderListDTO.class, mapOrderListClass);
return greenMarketController.marketOrderList(greenFoodOrderListDTO);
} else if ("greenMarket/marketPickUp".equals(method)) {
if (Utils.list.contains("greenMarket/marketPickUp" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMarket/marketPickUp" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenMarketController.marketPickUp(map);
} else if ("greenFoodsMenu/getAttrTypes".equals(method)) {
if (Utils.list.contains("greenFoodsMenu/getAttrTypes" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFoodsMenu/getAttrTypes" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenFoodsMenuController.getAttrTypes(map);
} else if ("greenFaultRepairInfo/cancleRepair".equals(method)) {
if (Utils.list.contains("greenFaultRepairInfo/cancleRepair" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenFaultRepairInfo/cancleRepair" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenFaultRepairInfoController.cancleRepair(map);
} else if ("greenMonitor/query".equals(method)) {
if (Utils.list.contains("greenMonitor/query" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenMonitor/query" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenMonitorController.query(map);
} else if ("greenWeekMenu/list".equals(method)) {
if (Utils.list.contains("greenWeekMenu/list" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMenu/list" + checkTime);
}
System.err.println(data);
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
System.err.println("1");
return greenWeekMenuController.list(map);
} else if ("greenWeekMenu/getWeeKCookBook".equals(method)) {
if (Utils.list.contains("greenWeekMenu/getWeeKCookBook" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMenu/getWeeKCookBook" + checkTime);
}
System.err.println(data);
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
System.err.println(greenWeekMenuController);
System.err.println("getWeeKCookBook");
return greenWeekMenuController.getWeeKCookBook(map);
} else if ("greenWeekMenu/getWeeKCookBookForDay".equals(method)) {
if (Utils.list.contains("greenWeekMenu/getWeeKCookBookForDay" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMenu/getWeeKCookBookForDay" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenWeekMenuController.getWeeKCookBookForDay(map);
} else if ("greenWeekMenu/getEvaluate".equals(method)) {
if (Utils.list.contains("greenWeekMenu/getEvaluate" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMenu/getEvaluate" + checkTime);
}
System.err.println("data的数据" + data);
// Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
QueryParams params = (QueryParams) JSONObject.toBean(data, QueryParams.class);
System.err.println("解析后的params" + params);
System.err.println("解析后的type" + params.getType());
System.err.println("调用食堂评价接口");
return greenWeekMenuController.getEvaluate(params);
} else if ("greenWeekMenu/addEvaluate".equals(method)) {
if (Utils.list.contains("greenWeekMenu/addEvaluate" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMenu/addEvaluate" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenWeekMenuController.addEvaluate(map);
} else if ("greenServiceGuide/list".equals(method)) {
if (Utils.list.contains("greenServiceGuide/list" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenServiceGuide/list" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenServiceGuideController.list(map);
} else if ("greenBanner/list".equals(method)) {
if (Utils.list.contains("greenBanner/list" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenBanner/list" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenBannerController.list(map);
} else if ("singleLogin/getUserInfoByTicket".equals(method)) {
if (Utils.list.contains("singleLogin/getUserInfoByTicket" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("singleLogin/getUserInfoByTicket" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return singleLoginController.getUserInfoByTicket(map);
} else if ("greenHouse/page".equals(method)) {
if (Utils.list.contains("greenHouse/page" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/page" + checkTime);
}
GreenRentHouseApply greenRentHouseApply = (GreenRentHouseApply) JSONObject.toBean(data,
GreenRentHouseApply.class);
return greenHouseController.page(greenRentHouseApply);
} else if ("greenHouse/examinePage".equals(method)) {
if (Utils.list.contains("greenHouse/examinePage" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/examinePage" + checkTime);
}
GreenRentHouseApply greenRentHouseApply = (GreenRentHouseApply) JSONObject.toBean(data,
GreenRentHouseApply.class);
return greenHouseController.examinePage(greenRentHouseApply);
} else if ("greenHouse/detail".equals(method)) {
if (Utils.list.contains("greenHouse/detail" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/detail" + checkTime);
}
GreenRentHouseApply greenRentHouseApply = (GreenRentHouseApply) JSONObject.toBean(data,
GreenRentHouseApply.class);
return greenHouseController.detail(greenRentHouseApply);
} else if ("greenHouse/apply".equals(method)) {
if (Utils.list.contains("greenHouse/apply" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/apply" + checkTime);
}
GreenRentHouseApply greenRentHouseApply = (GreenRentHouseApply) JSONObject.toBean(data,
GreenRentHouseApply.class);
return greenHouseController.apply(greenRentHouseApply);
} else if ("greenHouse/examine".equals(method)) {
if (Utils.list.contains("greenHouse/examine" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/examine" + checkTime);
}
Map<String, String> map = (Map<String, String>) JSONObject.toBean(data, Map.class);
return greenHouseController.examine(map);
} else if ("greenHouse/addSelectedHouse".equals(method)) {
if (Utils.list.contains("greenHouse/addSelectedHouse" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/addSelectedHouse" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenHouseController.addSelectedHouse(map);
} else if ("greenHouse/checkedHouse".equals(method)) { // 房管经办人选房-cw
if (Utils.list.contains("greenHouse/checkedHouse" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/checkedHouse" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenHouseController.checkedHouse(map);
} else if ("greenHouse/getSelectedHouse".equals(method)) {
if (Utils.list.contains("greenHouse/getSelectedHouse" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/getSelectedHouse" + checkTime);
}
Map<String, String> map = (Map<String, String>) JSONObject.toBean(data, Map.class);
return greenHouseController.getSelectedHouse(map);
} else if ("greenHouse/houseCheckOut".equals(method)) {
if (Utils.list.contains("greenHouse/houseCheckOut" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/houseCheckOut" + checkTime);
}
Map<String, String> map = (Map<String, String>) JSONObject.toBean(data, Map.class);
return greenHouseController.houseCheckOut(map);
} else if ("greenHouse/getHouseType".equals(method)) {
if (Utils.list.contains("greenHouse/getHouseType" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/getHouseType" + checkTime);
}
Map<String, String> map = (Map<String, String>) JSONObject.toBean(data, Map.class);
return greenHouseController.getHouseType(map);
} else if ("greenHouse/getHouseTypes".equals(method)) {
if (Utils.list.contains("greenHouse/getHouseTypes" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/getHouseTypes" + checkTime);
}
Map<String, String> map = (Map<String, String>) JSONObject.toBean(data, Map.class);
return greenHouseController.getHouseTypes(map);
}else if ("greenHouse/getFreeHouse".equals(method)) {
if (Utils.list.contains("greenHouse/getFreeHouse" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/getFreeHouse" + checkTime);
}
Map<String, String> map = (Map<String, String>) JSONObject.toBean(data, Map.class);
return greenHouseController.getFreeHouse(map);
} else if ("greenHouse/getUserTypeByRole".equals(method)) { // 根据角色获取人员类型 -cw
if (Utils.list.contains("greenHouse/getUserTypeByRole" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/getUserTypeByRole" + checkTime);
}
GreenHouseDto dto = (GreenHouseDto)JSONObject.toBean(data, GreenHouseDto.class);
return greenHouseController.getUserTypeByRole(dto);
}else if ("greenHouse/getHouseTypeByRole".equals(method)) { // 根据角色查看不同的房源类型 -cw
if (Utils.list.contains("greenHouse/getHouseTypeByRole" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenHouse/getHouseTypeByRole" + checkTime);
}
GreenHouseDto dto = (GreenHouseDto) JSONObject.toBean(data, GreenHouseDto.class);
return greenHouseController.getHouseTypeByRole(dto);
}else if ("greenEpidemic/travelReportAdd".equals(method)) {
if (Utils.list.contains("greenEpidemic/travelReportAdd" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/travelReportAdd" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.travelReportAdd(map);
} else if ("greenEpidemic/travelReportPage".equals(method)) {
if (Utils.list.contains("greenEpidemic/travelReportPage" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/travelReportPage" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.travelReportPage(map);
} else if ("greenEpidemic/addEpidemicInfo".equals(method)) {
if (Utils.list.contains("greenEpidemic/addEpidemicInfo" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/addEpidemicInfo" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.addEpidemicInfo(map);
} else if ("greenEpidemic/epidemicPage".equals(method)) {
if (Utils.list.contains("greenEpidemic/epidemicPage" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/epidemicPage" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.epidemicPage(map);
} else if ("greenEpidemic/epidemicDetail".equals(method)) {
if (Utils.list.contains("greenEpidemic/epidemicDetail" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/epidemicDetail" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.epidemicDetail(map);
} else if ("greenEpidemic/travelPolicy".equals(method)) {
if (Utils.list.contains("greenEpidemic/travelPolicy" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/travelPolicy" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.travelPolicy(map);
} else if ("greenUserInfo/getUserPermission3".equals(method)) {
if (Utils.list.contains("greenUserInfo/getUserPermission3" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenUserInfo/getUserPermission3" + checkTime);
}
String userIdString = data.getString("userId");
String parentCode = data.getString("parentCode");
return greenUserInfoController.getUserPermission3(userIdString, parentCode);
} else if ("greenEpidemic/travelPolicyList".equals(method)) {
if (Utils.list.contains("greenEpidemic/travelPolicyList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/travelPolicyList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.travelPolicyList(map);
} else if ("greenEpidemic/travelExamine".equals(method)) {
if (Utils.list.contains("greenEpidemic/travelExamine" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/travelExamine" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.travelExamine(map);
} else if ("greenEpidemic/travelExaminePage".equals(method)) {
if (Utils.list.contains("greenEpidemic/travelExaminePage" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/travelExaminePage" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.travelExaminePage(map);
} else if ("greenEpidemic/travelReportDetail".equals(method)) {
if (Utils.list.contains("greenEpidemic/travelReportDetail" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/travelReportDetail" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.travelReportDetail(map);
} else if ("greenEpidemic/getDeptExamineAuth".equals(method)) {
if (Utils.list.contains("greenEpidemic/getDeptExamineAuth" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/getDeptExamineAuth" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.getDeptExamineAuth(map);
} else if ("greenEpidemic/healthyClockAdd".equals(method)) {
if (Utils.list.contains("greenEpidemic/healthyClockAdd" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/healthyClockAdd" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.healthyClockAdd(map);
} else if ("greenEpidemic/healthyClockList".equals(method)) {
if (Utils.list.contains("greenEpidemic/healthyClockList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/healthyClockList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.healthyClockList(map);
} else if ("greenEpidemic/vaccinationAdd".equals(method)) {
if (Utils.list.contains("greenEpidemic/vaccinationAdd" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/vaccinationAdd" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.vaccinationAdd(map);
} else if ("greenEpidemic/vaccinationList".equals(method)) {
if (Utils.list.contains("greenEpidemic/vaccinationList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/vaccinationList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.vaccinationList(map);
} else if ("greenEpidemic/materialAdd".equals(method)) {
if (Utils.list.contains("greenEpidemic/materialAdd" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/materialAdd" + checkTime);
}
Map<String, Class> mapClass = new HashMap<String, Class>();
mapClass.put("supplies", Map.class);
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class, mapClass);
return greenEpidemicController.materialAdd(map);
// Map<String, Class> mapClass = new HashMap<String, Class>();
// mapClass.put("orderDetails", GreenFoodOrderDetailDTO.class);
// GreenFoodOrderListDTO greenfoodorderlists =
// (GreenFoodOrderListDTO) JSONObject.toBean(data,
// GreenFoodOrderListDTO.class, mapClass);
} else if ("greenEpidemic/materialList".equals(method)) {
if (Utils.list.contains("greenEpidemic/materialList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/materialList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.materialList(map);
} else if ("greenEpidemic/materialDetail".equals(method)) {
if (Utils.list.contains("greenEpidemic/materialDetail" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/materialDetail" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.materialDetail(map);
} else if ("greenEpidemic/materialExaminePage".equals(method)) {
if (Utils.list.contains("greenEpidemic/materialExamPage" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/materialExaminePage" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.materialExaminePage(map);
} else if ("greenEpidemic/materialExam".equals(method)) {
if (Utils.list.contains("greenEpidemic/materialExam" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/materialExam" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.materialExam(map);
} else if ("greenEpidemic/travelCheckThemeList".equals(method)) {
if (Utils.list.contains("greenEpidemic/travelCheckThemeList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/travelCheckThemeList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.travelCheckThemeList(map);
} else if ("greenEpidemic/getMaterialExamUser".equals(method)) {
if (Utils.list.contains("greenEpidemic/getMaterialExamUser" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/getMaterialExamUser" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.getMaterialExamUser(map);
} else if ("greenEpidemic/vaccineStatic".equals(method)) {
if (Utils.list.contains("greenEpidemic/vaccineStatic" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/vaccineStatic" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.vaccineStatic(map);
} else if ("greenEpidemic/getMaterialInfoList".equals(method)) {
if (Utils.list.contains("greenEpidemic/getMaterialInfoList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenEpidemic/getMaterialInfoList" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenEpidemicController.getMaterialInfoList(map);
} else if ("greenVisitor/addVisitor".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenVisitor/addVisitor" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitor/addVisitor" + checkTime);
}
GreenVisitor entity = (GreenVisitor) JSONObject.toBean(data, GreenVisitor.class);
return visitorController.addVisitor(entity);
}else if ("greenVisitor/addVisitor".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenVisitor/addVisitor" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitor/addVisitor" + checkTime);
}
GreenVisitor entity = (GreenVisitor) JSONObject.toBean(data, GreenVisitor.class);
return visitorController.addVisitor(entity);
} else if ("greenVisitor/getHisInvitationByUserId".equals(method)) {// 历史邀约人员 cw
if (Utils.list.contains("greenVisitor/getHisInvitationByUserId" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitor/getHisInvitationByUserId" + checkTime);
}
GreenVisitor entity = (GreenVisitor) JSONObject.toBean(data, GreenVisitor.class);
return visitorController.getHisInvitationByUserId(entity);
}else if ("greenVisitor/getVisitor".equals(method)) {// 通过id获取来访记录
if (Utils.list.contains("greenVisitor/getVisitor" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitor/getVisitor" + checkTime);
}
GreenVisitor entity = (GreenVisitor) JSONObject.toBean(data, GreenVisitor.class);
return visitorController.getVisitor(entity);
} else if ("greenVisitor/getVisitorEventNotify".equals(method)) {// 根据id和申请类型查询申请详情 cw
if (Utils.list.contains("greenVisitor/getVisitorEventNotify" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitor/getVisitorEventNotify" + checkTime);
}
GreenVisitor entity = (GreenVisitor) JSONObject.toBean(data, GreenVisitor.class);
return visitorController.getVisitorEventNotify(request,response);
}else if ("greenVisitor/updateVisitor".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenVisitor/updateVisitor" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitor/updateVisitor" + checkTime);
}
GreenVisitor entity = (GreenVisitor) JSONObject.toBean(data, GreenVisitor.class);
return visitorController.updateVisitor(entity);
} else if ("greenVisitor/getReceiveVisitorByUserId".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenVisitor/getReceiveVisitorByUserId" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitor/getReceiveVisitorByUserId" + checkTime);
}
GreenVisitor entity = (GreenVisitor) JSONObject.toBean(data, GreenVisitor.class);
return visitorController.getReceiveVisitorByUserId(entity);
} else if ("greenVisitor/getIssueVisitorByUserId".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenVisitor/getIssueVisitorByUserId" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitor/getIssueVisitorByUserId" + checkTime);
}
GreenVisitor entity = (GreenVisitor) JSONObject.toBean(data, GreenVisitor.class);
return visitorController.getIssueVisitorByUserId(entity);
} else if ("greenVisitor/getDeptExamineAuth".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenVisitor/getDeptExamineAuth" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenVisitor/getDeptExamineAuth" + checkTime);
}
GreenVisitor entity = (GreenVisitor) JSONObject.toBean(data, GreenVisitor.class);
return visitorController.getDeptExamineAuth(entity);
} else if ("greenProperty/getPropertyByUserId".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenProperty/getPropertyByUserId" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenProperty/getPropertyByUserId" + checkTime);
}
GreenPropertyEntity entity = (GreenPropertyEntity) JSONObject.toBean(data, GreenPropertyEntity.class);
return propertyController.getPropertyByUserId(entity);
} else if ("greenProperty/addProperty".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenProperty/addProperty" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenProperty/addProperty" + checkTime);
}
GreenPropertyEntity entity = (GreenPropertyEntity) JSONObject.toBean(data, GreenPropertyEntity.class);
return propertyController.addProperty(entity);
} else if ("greenProperty/getPropertyType".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenProperty/getPropertyType" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenProperty/getPropertyType" + checkTime);
}
GreenPropertyEntity entity = (GreenPropertyEntity) JSONObject.toBean(data, GreenPropertyEntity.class);
return propertyController.getPropertyType(entity);
} else if ("greenProperty/getProperty".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenProperty/getProperty" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenProperty/getProperty" + checkTime);
}
GreenPropertyEntity entity = (GreenPropertyEntity) JSONObject.toBean(data, GreenPropertyEntity.class);
return propertyController.getProperty(entity);
} else if ("greenProperty/updateProperty".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenProperty/updateProperty" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenProperty/updateProperty" + checkTime);
}
GreenPropertyEntity entity = (GreenPropertyEntity) JSONObject.toBean(data, GreenPropertyEntity.class);
return propertyController.updateProperty(entity);
}else if ("greenProperty/addServiceEvaluate".equals(method)) {// 服务申请-服务评价 cw
if (Utils.list.contains("greenProperty/addServiceEvaluate" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenProperty/addServiceEvaluate" + checkTime);
}
GreenPropertyEntity entity = (GreenPropertyEntity) JSONObject.toBean(data, GreenPropertyEntity.class);
return propertyController.addServiceEvaluate(entity);
} else if ("greenCard/addCard".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenCard/addCard" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/addCard" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.addCard(entity);
}else if ("greenCard/getAccessControlList".equals(method)) {// 门禁卡办理-出入区域 cw
if (Utils.list.contains("greenCard/getAccessControlList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/getAccessControlList" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.getAccessControlList(entity);
}else if ("greenCard/updateCardStatusById".equals(method)) {// 门禁卡办理-申请人更新领卡状态 cw
if (Utils.list.contains("greenCard/updateCardStatusById" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/updateCardStatusById" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.updateCardStatusById(entity);
}else if ("greenCard/getAllCardList".equals(method)) {// 门禁卡办理-卡挂失 cw
if (Utils.list.contains("greenCard/getAllCardList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/getAllCardList" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.getAllCardList(entity);
}else if ("greenCard/reissueCard".equals(method)) {// 门禁卡办理-补办卡 cw
if (Utils.list.contains("greenCard/reissueCard" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/reissueCard" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.reissueCard(entity);
}else if ("greenCard/getCard".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenCard/getCard" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/getCard" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.getCard(entity);
} else if ("greenCard/updateCard".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenCard/updateCard" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/updateCard" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.updateCard(entity);
} else if ("greenCard/getCardByUserId".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenCard/getCardByUserId" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/getCardByUserId" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.getCardByUserId(entity);
} else if ("greenCard/getIssueCardByUserId".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenCard/getIssueCardByUserId" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/getIssueCardByUserId" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.getIssueCardByUserId(entity);
}
else if ("greenCard/getCardType".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenCard/getCardType" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/getCardType" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.getCardType(entity);
} else if ("greenCard/getDeptExamineAuth".equals(method)) {// 根据id和申请类型查询申请详情
if (Utils.list.contains("greenCard/getDeptExamineAuth" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenCard/getDeptExamineAuth" + checkTime);
}
GreenCard entity = (GreenCard) JSONObject.toBean(data, GreenCard.class);
return cardController.getDeptExamineAuth(entity);
} else if ("greenQuestionnaire/getQuestionnaireList".equals(method)) {
if (Utils.list.contains("greenQuestionnaire/getQuestionnaireList" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenQuestionnaire/getQuestionnaireList" + checkTime);
}
GreenQuestionnaire entity = (GreenQuestionnaire) JSONObject.toBean(data, GreenQuestionnaire.class);
return questionnaireController.getQuestionnaireList(entity);
} else if ("greenQuestionnaire/getQuestionnaireById".equals(method)) {
if (Utils.list.contains("greenQuestionnaire/getQuestionnaireById" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenQuestionnaire/getQuestionnaireById" + checkTime);
}
GreenQuestionnaire entity = (GreenQuestionnaire) JSONObject.toBean(data, GreenQuestionnaire.class);
return questionnaireController.getQuestionnaireById(entity);
} else if ("greenQuestionnaire/updateQuestionnaire".equals(method)) {
if (Utils.list.contains("greenQuestionnaire/updateQuestionnaire" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenQuestionnaire/updateQuestionnaire" + checkTime);
}
GreenQuestionnaire entity = JSON.parseObject(data.toString(), GreenQuestionnaire.class);
return questionnaireController.updateQuestionnaire(entity);
} else if ("greenWeekMeal/list".equals(method)) {
if (Utils.list.contains("greenWeekMeal/list" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMeal/list" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenWeekMealController.list(map);
} else if ("greenWeekMeal/add".equals(method)) {
if (Utils.list.contains("greenWeekMeal/add" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMeal/add" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenWeekMealController.add(map);
} else if ("greenWeekMeal/del".equals(method)) {
if (Utils.list.contains("greenWeekMeal/del" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMeal/del" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenWeekMealController.del(map);
} else if ("greenWeekMeal/updateState".equals(method)) {
if (Utils.list.contains("greenWeekMeal/updateState" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMeal/updateState" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenWeekMealController.updateState(map);
} else if ("greenWeekMeal/get".equals(method)) {
if (Utils.list.contains("greenWeekMeal/get" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMeal/get" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenWeekMealController.get(map);
}
else if ("greenWeekMeal/getNum".equals(method)) {
if (Utils.list.contains("greenWeekMeal/getNum" + checkTime)) {
return new RestResult(Constant.FAILED, "您的请求存在异常!请重新请求...");
} else {
Utils.list.add("greenWeekMeal/getNum" + checkTime);
}
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(data, Map.class);
return greenWeekMealController.getNum(map);
}
else {
System.out.println("请求失败");
return new RestResult(Constant.FAILED, "请求失败");
}
} catch (Exception e) {
System.out.println("+++++++++++++++:" + jsonStr);
// TODO Auto-generated catch block
e.printStackTrace();
return new RestResult(Constant.FAILED, "请求失败");
}
}
/**
* 描述:获取 post 请求的 byte[] 数组
*
* <pre>
* 举例:
* </pre>
*
* @param request
* @return
* @throws IOException
*/
public static byte[] getRequestPostBytes(HttpServletRequest request) throws IOException {
int contentLength = request.getContentLength();
System.out.println("contentLength:" + contentLength);
if (contentLength < 0) {
return null;
}
byte buffer[] = new byte[contentLength];
for (int i = 0; i < contentLength;) {
int readlen = request.getInputStream().read(buffer, i, contentLength - i);
if (readlen == -1) {
break;
}
i += readlen;
}
return buffer;
}
}