/*
 *      Copyright (c) 2018-2028, Chill Zhuang All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *  Neither the name of the dreamlu.net developer nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  Author: Chill 庄骞 (smallchill@163.com)
 */
package org.springblade.modules.information.controller;

import io.swagger.annotations.*;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import lombok.AllArgsConstructor;

import javax.validation.Valid;

import org.springblade.common.cache.DictCache;
import org.springblade.common.enums.DictEnum;
import org.springblade.core.cache.utils.CacheUtil;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.support.Kv;
import org.springblade.core.tool.utils.Func;
import org.springblade.modules.desk.entity.Notice;
import org.springblade.modules.desk.vo.NoticeVO;
import org.springblade.modules.desk.wrapper.NoticeWrapper;
import org.springblade.modules.jurisdiction.service.JurisdictionService;
import org.springblade.modules.jurisdiction.vo.JurisdictionVO;
import org.springblade.modules.member.service.IMemberService;
import org.springblade.modules.shareholder.service.IShareholderService;
import org.springblade.modules.system.entity.Dept;
import org.springblade.modules.system.service.IDeptService;
import org.springblade.modules.system.service.IUserDeptService;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.springblade.modules.information.entity.Information;
import org.springblade.modules.information.vo.InformationVO;
import org.springblade.modules.information.service.IInformationService;
import org.springblade.core.boot.ctrl.BladeController;
import springfox.documentation.annotations.ApiIgnore;

import java.util.*;

import static org.springblade.core.cache.constant.CacheConstant.SYS_CACHE;

/**
 * 控制器
 *
 * @author BladeX
 * @since 2021-07-07
 */
@RestController
@AllArgsConstructor
@RequestMapping("/information")
@Api(value = "", tags = "接口")
public class InformationController extends BladeController {

	private final IInformationService informationService;
	private final IDeptService iDeptService;
	private final JurisdictionService jurisdictionService;


	/**
	 * 详情
	 */
	@GetMapping("/detail")
	@ApiOperationSupport(order = 1)
	@ApiOperation(value = "详情", notes = "传入information")
	public R<Information> detail(Information information) {
		Information detail = informationService.getOne(Condition.getQueryWrapper(information));
		return R.data(detail);
	}

	/**
	 * 分页
	 */
	@GetMapping("/list")
	@ApiOperationSupport(order = 2)
	@ApiOperation(value = "分页", notes = "传入information")
	public R<IPage<Information>> list(@ApiIgnore @RequestParam Map<String, Object> information, Query query) {
		IPage<Information> pages = informationService.page(Condition.getPage(query), Condition.getQueryWrapper(information, Information.class));
		return R.data(pages);
	}

	/**
	 * 自定义分页
	 */
	@GetMapping("/page")
	@ApiOperationSupport(order = 3)
	@ApiOperation(value = "分页", notes = "传入information")
	public R<IPage<Information>> page(Information information, Query query) {
		IPage<Information> pages = informationService.selectInformationPage(Condition.getPage(query), information);
		return R.data(pages);
	}

	/**
	 * 新增
	 */
	@PostMapping("/save")
	@ApiOperationSupport(order = 4)
	@ApiOperation(value = "新增", notes = "传入information")
	public R save(@Valid @RequestBody Information information) {
		Dept dept= new Dept();
		Long i = 1413470343230877697L;
		dept.setParentId(i);
		dept.setTenantId("000000");
		dept.setDeptName(information.getEnterprisename());
		dept.setAncestors("0,1413470343230877697");
		dept.setDeptCategory(1);
		if (iDeptService.submit(dept)) {
			CacheUtil.clear(SYS_CACHE);
			// 返回懒加载树更新节点所需字段
			Kv kv = Kv.create().set("id", String.valueOf(dept.getId())).set("tenantId", dept.getTenantId())
				.set("deptCategoryName", DictCache.getValue(DictEnum.ORG_CATEGORY, dept.getDeptCategory()));
			String id = kv.get("id").toString();
			information.setDepartmentid(id);
		}
		return R.status(informationService.save(information));
	}

	/**
	 * 修改
	 */
	@PostMapping("/update")
	@ApiOperationSupport(order = 5)
	@ApiOperation(value = "修改", notes = "传入information")
	public R update(@Valid @RequestBody Information information) {
		return R.status(informationService.updateById(information));
	}

	/**
	 * 新增或修改
	 */
	@PostMapping("/submit")
	@ApiOperationSupport(order = 6)
	@ApiOperation(value = "新增或修改", notes = "传入information")
	public R submit(@Valid @RequestBody Information information) {
		return R.status(informationService.saveOrUpdate(information));
	}


	/**
	 * 删除
	 */
	@PostMapping("/remove")
	@ApiOperationSupport(order = 8)
	@ApiOperation(value = "删除", notes = "传入ids")
	public R remove(String creditcode) {
		informationService.deleteIn(creditcode);
		informationService.deleteSh(creditcode);
		informationService.deleteMe(creditcode);
		return R.success("删除成功");
	}

	/**
	 * 首页保安公司统计接口
	 *
	 * @return
	 */
	@PostMapping("/SelectCount")
	public R SelectCount() {
		List<Map<Object, String>> list = iDeptService.selectCount();
		List<Map<String, Object>> lists = new ArrayList<>();
		for (int i = 0; i < list.size(); i++) {
			String title = list.get(i).get("title");//部门名称
			String departmentid = String.valueOf(list.get(i).get("jurisdiction"));//部门id
			Map<String, Object> map = new HashMap<String, Object>();
			Map maps = informationService.selectCount(departmentid);
			map.put("name", title);
			map.put("server", maps);
			lists.add(map);
		}
		return R.data(lists);
	}

	/**
	 * 首页保安持证统计接口
	 *
	 * @return
	 */
	@PostMapping("/SelectCounthold")
	public R SelectCounthold() {
		List<Map<Object, String>> list = iDeptService.selectCount();
		List<Map<String, Object>> lists = new ArrayList<>();
		for (int i = 0; i < list.size(); i++) {
			int cznumber = 0;//总的持证数量
			int wcznumber = 0;//总的未持证数量
			String title = list.get(i).get("title");//部门名称
			Map<String, Object> map = new HashMap<String, Object>();
			Map<Object, Integer> objectStringMap = iDeptService.selectHold(String.valueOf(list.get(i).get("jurisdiction")));
			if (objectStringMap==null) {
				map.put("name", title);
				map.put("cz", cznumber);
				map.put("wcz", wcznumber);
				lists.add(map);
			}
			else {
				cznumber = objectStringMap.get("cz");
				wcznumber = objectStringMap.get("wcz");
				map.put("name", title);
				map.put("cz", cznumber);
				map.put("wcz", wcznumber);
				lists.add(map);
			}
		}
		return R.data(lists);
	}


	/**
	 * 统计保安公司未持证的保安的公司数量
	 */
	@PostMapping("/selectInCount")
	public R selectInCount(String jurisdiction,String deptid) {
		List<Map<Object, String>> maps = informationService.selectInCount(jurisdiction,deptid);
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("Count",maps.size());
		map.put("List",maps);
		List<Map<String, Object>> lists = new ArrayList<>();
		lists.add(map);
		return R.data(lists);
	}


	/**  未缴社保数量
	 * 通过辖区查询机构id，然后通过机构id查询当前机构交社保的人数（numj单位已交社保数量;numz单位人员总数）
	 */
	@PostMapping("/selectCs")
	public R selectCs(String jurisdiction,String deptid) {
		List<Map<String, Object>> maps = informationService.selectCs(jurisdiction,deptid);
		List<Map<String, Object>> lists = new ArrayList<>();
		List<Map<String, Object>> lists1 = new ArrayList<>();
		Map<String, Object> map1 = new HashMap<String, Object>();
		Integer count=0;
		for (int i=0;i<maps.size();i++){
			Map<String, Object> map = new HashMap<String, Object>();
			//交社保数
			String numjs = maps.get(i).get("numj").toString();
			Integer numj = Integer.parseInt(numjs);
			//单位总人数
			String numzs = maps.get(i).get("numz").toString();
			Integer numz = Integer.parseInt(numzs);
			String deptname = maps.get(i).get("deptname").toString();
			//统计未交社保人数
			int i1 = numz - numj;
			count+=i1;
			map.put("count",i1);
			map.put("name",deptname);
			lists1.add(map);
		}
		map1.put("Count",count);
		map1.put("List",lists1);
		lists.add(map1);
		return R.data(lists);
	}


	/**
	 * 管辖区域下拉
	 */
	@PostMapping("/selecttree")
	public R selecttree() {
		List<Map<Object, String>> maps = iDeptService.selectCount();
		return R.data(maps);
	}

	/**
	 * 管辖区域下拉
	 */
	@PostMapping("/lazyTreeJu")
	public R lazyTreeJu() {
		List<JurisdictionVO> jurisdictionVOS = jurisdictionService.lazyTreeJu();
		return R.data(jurisdictionVOS);
	}


	/**
	 * 统计这个月和上个月交社保的人数，以及金额
	 * @return
	 */
	@PostMapping("/selectTo")
	public R selectTo(String jurisdiction,String deptid) {
		//上个月人数数量
		Integer lnum=0;
		//这个月人数数量
		Integer tnum=0;
		//上个月金额
		Double lmount=0.0;
		//这个月金额
		Double tmount=0.0;
		Map<String, Object> map = new HashMap<String, Object>();
		List<Map<String, Object>> lists = new ArrayList<>();
		List<Map<String, Object>> list = informationService.selectTo(jurisdiction,deptid);
		for (int i=0;i<list.size();i++){
			String lastmonths = list.get(i).get("lastmonth").toString();
			Integer lastmonth=Integer.parseInt(lastmonths);
			lnum+=lastmonth;
			String thismouths = list.get(i).get("thismouth").toString();
			Integer thismouth=Integer.parseInt(thismouths);
			tnum+=thismouth;
			String lastamounts = list.get(i).get("lastamount").toString();
			Double lastamount =Double.parseDouble(lastamounts);
			lmount+=lastamount;
			String thisamounts = list.get(i).get("thisamount").toString();
			Double thisamount =Double.parseDouble(thisamounts);
			tmount+=thisamount;
		}
		map.put("lastmonth",lnum);
		map.put("thismouth",tnum);
		map.put("lastamount",lmount);
		map.put("thisamount",tmount);
		lists.add(map);
		return R.data(lists);
	}


	/**
	 * 查询本年所有月份交社保人数
	 * @return
	 */
	@GetMapping("/queryYearSoil")
	public R queryYearSoil(String jurisdiction,String deptid) {
		Calendar cal = Calendar.getInstance();
		String year = String.valueOf(cal.get(Calendar.YEAR));
		Map<String, String> map = informationService.queryYearSoil(year,jurisdiction,deptid);
		map = (HashMap<String, String>) sortMapBykeyAsc(map) ;//key升序
		return R.data(map);
	}

	/**
	 * 查询本年所有月份社保金额
	 * @return
	 */
	@GetMapping("/queryYearAn")
	public R queryYearAn(String jurisdiction,String deptid) {
		Calendar cal = Calendar.getInstance();
		String year = String.valueOf(cal.get(Calendar.YEAR));
		Map<String, String> map = informationService.queryYearAn(year,jurisdiction,deptid);
		map = (HashMap<String, String>) sortMapBykeyAsc(map) ;//key升序
		return R.data(map);
	}


	/**
	 * 公司运营智能统计
	 * @return
	 */
	@GetMapping("/queryCounts")
	public R queryCounts(String jurisdiction,String deptid) {
		List<Map<String, Object>> lists = new ArrayList<>();
		Integer a=0;
		Integer b=0;
		Integer zca=0;
		Integer zcb=0;
		Integer cza=0;
		Integer czb=0;
		Integer sba=0;
		Integer sbb=0;
		Integer kha=0;
		Integer khb=0;
		Integer pqa=0;
		Integer pqb=0;
		String deptname=null;
		String jurname=null;
		//保安员数量
		Map<String, Object> map = new HashMap<String, Object>();
		Map<String, Object> mapzc = new HashMap<String, Object>();
		Map<String, Object> mapcz = new HashMap<String, Object>();
		Map<String, Object> mapsb = new HashMap<String, Object>();
		Map<String, Object> mapkh = new HashMap<String, Object>();
		Map<String, Object> mappq = new HashMap<String, Object>();
		Map<String, Object> mapC = new HashMap<String, Object>();
		List<Map<Object, Object>> maps = informationService.queryCountB(jurisdiction, deptid);
		for (int i=0;i<maps.size();i++){
			//这个月数量
			String thisnum = maps.get(i).get("thisnum").toString();
			a+= Integer.valueOf(thisnum);
			//上个月数量
			String lastnum = maps.get(i).get("lastnum").toString();
			b+=Integer.valueOf(lastnum);

		}
		map.put("thisnum",a);
		map.put("lastnum",b);
		map.put("List",maps);
		mapC.put("baoan",map);
		//正常保安员数量
		List<Map<Object, Object>> maps1 = informationService.queryCountZc(jurisdiction, deptid);
		for (int i=0;i<maps1.size();i++){
			//这个月数量
			String thisnum = maps1.get(i).get("thisnum").toString();
			zca+= Integer.valueOf(thisnum);
			//上个月数量
			String lastnum = maps1.get(i).get("lastnum").toString();
			zcb+= Integer.valueOf(lastnum);
		}
		mapzc.put("thisnum",zca);
		mapzc.put("lastnum",zcb);
		mapzc.put("List",maps1);
		mapC.put("zcbaoan",mapzc);
		//持证保安数量
		List<Map<Object, Object>> maps2 = informationService.queryCountCz(jurisdiction, deptid);
		for (int i=0;i<maps2.size();i++){
			//这个月数量
			String thisnum = maps2.get(i).get("thisnum").toString();
			cza+= Integer.valueOf(thisnum);
			//上个月数量
			String lastnum = maps2.get(i).get("lastnum").toString();
			czb+= Integer.valueOf(lastnum);
		}
		mapcz.put("thisnum",cza);
		mapcz.put("lastnum",czb);
		mapcz.put("List",maps2);
		mapC.put("czbaoan",mapcz);
		//缴纳社保数量
		List<Map<Object, Object>> maps3 = informationService.queryCountSb(jurisdiction, deptid);
		for (int i=0;i<maps3.size();i++){
			//这个月数量
			String thisnum = maps3.get(i).get("thisnum").toString();
			sba+= Integer.valueOf(thisnum);
			//上个月数量
			String lastnum = maps3.get(i).get("lastnum").toString();
			sbb+= Integer.valueOf(lastnum);
		}
		mapsb.put("thisnum",sba);
		mapsb.put("lastnum",sbb);
		mapsb.put("List",maps3);
		mapC.put("sheb",mapsb);
		//服务客户数量
		List<Map<Object, Object>> maps4 = informationService.queryCountKh(jurisdiction, deptid);
		for (int i=0;i<maps4.size();i++){
			//这个月数量
			String thisnum = maps4.get(i).get("thisnum").toString();
			kha+= Integer.valueOf(thisnum);
			//上个月数量
			String lastnum = maps4.get(i).get("lastnum").toString();
			khb+= Integer.valueOf(lastnum);
		}
		mapkh.put("thisnum",kha);
		mapkh.put("lastnum",khb);
		mapkh.put("List",maps4);
		mapC.put("kh",mapkh);
		//保安派遣数量
		List<Map<Object, Object>> maps5 = informationService.queryCountPq(jurisdiction, deptid);
		for (int i=0;i<maps5.size();i++){
			//这个月数量
			String thisnum = maps5.get(i).get("thisnum").toString();
			pqa+= Integer.valueOf(thisnum);
			//上个月数量
			String lastnum = maps5.get(i).get("lastnum").toString();
			pqb+= Integer.valueOf(lastnum);
		}
		mappq.put("thisnum",pqa);
		mappq.put("lastnum",pqb);
		mappq.put("List",maps5);
		mapC.put("paiq",mappq);
		lists.add(mapC);
		return R.data(lists);
	}



	/**
	 * 查询本年公司运营智能统计
	 * @return
	 */
	@GetMapping("/queryYearG")
	public R queryYearG(String jurisdiction,String deptid) {
		Calendar cal = Calendar.getInstance();
		String year = String.valueOf(cal.get(Calendar.YEAR));
		Map<String, Object> mapz = new HashMap<String, Object>();
		Map<String, Object> mapzc1= new HashMap<String, Object>();
		Map<String, Object> mapcz1= new HashMap<String, Object>();
		Map<String, Object> mapsb1= new HashMap<String, Object>();
		List<Map<String, Object>> lists = new ArrayList<>();
		Map<String, String> map = informationService.queryYearZ(year,jurisdiction,deptid);
		map = (HashMap<String, String>) sortMapBykeyAsc(map) ;//key升序
		mapz.put("baoan",map);
		lists.add(mapz);
		//正常保安数量
		Map<String, String> mapzc = informationService.queryYearZc(year,jurisdiction,deptid);
		mapzc = (HashMap<String, String>) sortMapBykeyAsc(mapzc) ;//key升序
		mapzc1.put("zc",mapzc);
		lists.add(mapzc1);
		//保安持证数量
		Map<String, String> mapcz = informationService.queryYearZc(year,jurisdiction,deptid);
		mapcz = (HashMap<String, String>) sortMapBykeyAsc(mapcz) ;//key升序
		mapcz1.put("chiz",mapcz);
		lists.add(mapcz1);
		//缴纳社保数
		Map<String, String> mapsb = informationService.queryYearSoil(year,jurisdiction,deptid);
		mapsb = (HashMap<String, String>) sortMapBykeyAsc(mapsb) ;//key升序
		mapsb1.put("sheb",mapsb);
		//保安派遣
		Map<String, String> mapde = informationService.queryYearBanan(year, jurisdiction, deptid);
		mapde = (HashMap<String, String>) sortMapBykeyAsc(mapde) ;//key升序
		mapsb1.put("paiq",mapde);
		lists.add(mapsb1);
		return R.data(lists);
	}


	/**
	 * 查询本年所有月份的客户数量
	 * @return
	 */
	@GetMapping("/queryYearKh")
	public R queryYearKh(String jurisdiction,String deptid) {
		Calendar cal = Calendar.getInstance();
		String year = String.valueOf(cal.get(Calendar.YEAR));
		Map<String, String> map = informationService.queryYearKh(year,jurisdiction,deptid);
		map = (HashMap<String, String>) sortMapBykeyAsc(map) ;//key升序
		return R.data(map);
	}


	/**
	 * 查询本年所有月份的保安派遣数量
	 * @return
	 */
	@GetMapping("/queryYearBanan")
	public R queryYearBanan(String jurisdiction,String deptid) {
		Calendar cal = Calendar.getInstance();
		String year = String.valueOf(cal.get(Calendar.YEAR));
		Map<String, String> map = informationService.queryYearBanan(year,jurisdiction,deptid);
		map = (HashMap<String, String>) sortMapBykeyAsc(map) ;//key升序
		return R.data(map);
	}
	//升序
	public  static Map<String, String> sortMapBykeyAsc(Map<String, String> oriMap) {
		Map<String, String> sortedMap = new LinkedHashMap<String, String>();
		try {
			if (oriMap != null && !oriMap.isEmpty()) {
				List<Map.Entry<String, String>> entryList = new ArrayList<Map.Entry<String, String>>(oriMap.entrySet());
				Collections.sort(entryList,
					new Comparator<Map.Entry<String, String>>() {
						public int compare(Map.Entry<String, String> entry2,
										   Map.Entry<String, String> entry1) {
							int value2 = 0, value1 = 0;
							try {
								value2 = Integer.parseInt(entry1.getKey());
								value1 = Integer.parseInt(entry2.getKey());
							} catch (NumberFormatException e) {
								value2 = 0;
								value1 = 0;
							}
							return value1 - value2;
						}
					});
				Iterator<Map.Entry<String, String>> iter = entryList.iterator();
				Map.Entry<String, String> tmpEntry = null;
				while (iter.hasNext()) {
					tmpEntry = iter.next();
					sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());
				}
			}
		} catch (Exception e) {
		}
		return sortedMap;
	}



	/**
	 * 统计保安员资格异常的数量
	 */
	@PostMapping("/selectExtype")
	public R selectExtype(String jurisdiction,String deptid) {
		Map<String, Object> map = new HashMap<String, Object>();
		Integer count=0;
		List<Map<String, Object>> lists = new ArrayList<>();
		List<Map<Object, Object>> maps = informationService.selectExtype(jurisdiction, deptid);
		for (int i=0;i<maps.size();i++){
			String num = maps.get(i).get("num").toString();
			count+= Integer.valueOf(num);
		}
		map.put("count",count);
		map.put("list",maps);
		lists.add(map);
		return R.data(lists);
	}

	/**
	 * 统计保安员表现差的数量
	 */
	@PostMapping("/selectBx")
	public R selectBx(String jurisdiction,String deptid) {
		Map<String, Object> map = new HashMap<String, Object>();
		Integer count=0;
		List<Map<String, Object>> lists = new ArrayList<>();
		List<Map<Object, Object>> maps = informationService.selectBx(jurisdiction, deptid);
		for (int i=0;i<maps.size();i++){
			String num = maps.get(i).get("num").toString();
			count+= Integer.valueOf(num);
		}
		map.put("count",count);
		map.put("list",maps);
		lists.add(map);
		return R.data(lists);
	}




	/**
	 * 分局预警统计
	 */
	@PostMapping("/selectFj")
	public R selectFj(){
		//辖区信息
		List<Map<Object, Object>> list = informationService.selectJur();
		List<Map<String, Object>> lists = new ArrayList<>();
		for (int i=0;i<list.size();i++){
			Integer count=0;
			Map<String, Object> map = new HashMap<String, Object>();
			//辖区id
			String jurisdiction = list.get(i).get("id").toString();
			//辖区名称
			String jurname = list.get(i).get("dept_name").toString();
			//保安员表现差预警数量
			List<Map<Object, Object>> mapbx = informationService.selectBx(jurisdiction, "");
			for (int ibx=0;ibx<mapbx.size();ibx++){
				String num = mapbx.get(ibx).get("num").toString();
				count+= Integer.valueOf(num);
			}
			//保安员资格异常的数量
			List<Map<Object, Object>> mapEx = informationService.selectExtype(jurisdiction, "");
			for (int iex=0;iex<mapEx.size();iex++){
				String num = mapEx.get(iex).get("num").toString();
				count+= Integer.valueOf(num);
			}
			//保安公司未持证数量
			List<Map<Object, String>> mapgs = informationService.selectInCount(jurisdiction,"");
			count+=mapgs.size();
			//未缴社保数量
			List<Map<String, Object>> mapsb = informationService.selectCs(jurisdiction,"");
			for (int isb=0;isb<mapsb.size();isb++){
				//交社保数
				String numjs = mapsb.get(isb).get("numj").toString();
				Integer numj = Integer.parseInt(numjs);
				//单位总人数
				String numzs = mapsb.get(isb).get("numz").toString();
				Integer numz = Integer.parseInt(numzs);
				//统计未交社保人数
				int i1 = numz - numj;
				count+=i1;
			}
			map.put("Count",count);
			map.put("jurname",jurname);
			lists.add(map);
		}
		return R.data(lists);
	}



	/**
	 * 派遣數量統計
	 */
	@PostMapping("/selectPCount")
	public R selectPCount(String jurisdiction,String deptid) {
		Map<String, Object> map = new HashMap<String, Object>();
		List<Map<String, Object>> lists = new ArrayList<>();
		Map map1 = informationService.selectPcount(jurisdiction, deptid);
		String pnum = map1.get("pnum").toString();
		Integer a=Integer.valueOf(pnum);
		Map map2 = informationService.selectWPcount(jurisdiction, deptid);
		String wpnum = map2.get("wpnum").toString();
		Integer b=Integer.valueOf(wpnum);
		map.put("PCount",a);
		map.put("WPCount",b);
		lists.add(map);
		return R.data(lists);
	}

	/**
	 * 单位列表
	 */
	@PostMapping("/selectIn")
	public R selectIn(String jurisdiction) {
		List<Map<Object, Object>> maps = informationService.selectIn(jurisdiction);
		return R.data(maps);
	}
}