Merge branch 'dev' of http://192.168.1.220:10080/Amoy/patient-co-management into dev

patient-co-wlyy/src/main/java/com/yihu/wlyy/entity/template/DoctorTeamGuidanceTemplate.java

@@ -16,7 +16,9 @@ import java.util.Date;
@Table(name = "wlyy_team_guidance_template")
public class DoctorTeamGuidanceTemplate extends IdEntity {
    //    团队ID
    private long teamId;
    private int teamId;
    //    团队ID名称
    private String teamName;
    //    团队指导模板code
    private String teamTemplateCode;
    //    团队模板创建者
@@ -32,11 +34,19 @@ public class DoctorTeamGuidanceTemplate extends IdEntity {
    //        团队内的团队模板状态  0删除  1正常
    private int del;
    public long getTeamId() {
    public String getTeamName() {
        return teamName;
    }
    public void setTeamName(String teamName) {
        this.teamName = teamName;
    }
    public int getTeamId() {
        return teamId;
    }
    public void setTeamId(long teamId) {
    public void setTeamId(int teamId) {
        this.teamId = teamId;
    }

patient-co-wlyy/src/main/java/com/yihu/wlyy/repository/template/DoctorTeamGuidanceDetailDao.java

@@ -1,7 +1,22 @@
package com.yihu.wlyy.repository.template;
import com.yihu.wlyy.entity.template.DoctorTeamGuidanceDetail;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
/**
 * Created by Reece on 2017/6/8.
 */
public interface DoctorTeamGuidanceDetailDao {
public interface DoctorTeamGuidanceDetailDao extends PagingAndSortingRepository<DoctorTeamGuidanceDetail, Long>, JpaSpecificationExecutor<DoctorTeamGuidanceDetail> {
    //根据模板编码获取有效的模板详情
    @Query("select distinct t from DoctorTeamGuidanceDetail t,DoctorTeamGuidanceTemplate a where t.code = a.teamTemplateCode and a.del = 1 and t.code = ?1 ")
    DoctorTeamGuidanceDetail findGuidanceDetail(String guidanceCode);
    //根据模板编码更改模板详情
    @Modifying
    @Query("update DoctorTeamGuidanceDetail t set t.title = ?1,t.content = ?2,t.imagesUrl = ?3 where t.code = ?4 ")
    int modifyTeamGuidanceDetail(String title,String content,String image,String guidance);
}

patient-co-wlyy/src/main/java/com/yihu/wlyy/repository/template/DoctorTeamGuidanceTemplateDao.java

@@ -1,7 +1,40 @@
package com.yihu.wlyy.repository.template;
import com.yihu.wlyy.entity.template.DoctorTeamGuidanceTemplate;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
import java.util.List;
/**
 * Created by Reece on 2017/6/8.
 */
public interface DoctorTeamGuidanceTemplateDao {
public interface DoctorTeamGuidanceTemplateDao extends PagingAndSortingRepository<DoctorTeamGuidanceTemplate, Long>, JpaSpecificationExecutor<DoctorTeamGuidanceTemplate> {
    //    新增团队模板时团队内标题排重
    @Query("select t from DoctorTeamGuidanceTemplate t where t.title = ?1 and t.teamId = ?2 ")
    List<DoctorTeamGuidanceTemplate> distinctByTeamTitle(String title, int teamId);
    //    根据团队ID获取团队内的模板列表（带分页和创建时间倒序）
    @Query("select t from DoctorTeamGuidanceTemplate t where t.del = 1 and t.teamId = ?1 ")
    List<DoctorTeamGuidanceTemplate> findGuidanceByTeamId(int teamId, Pageable request);
    //    根据团队ID及模板编码删除团队所属的团队模板
    @Modifying
    @Query("update DoctorTeamGuidanceTemplate t set t.del = 0 where t.teamId = ?1 and t.teamTemplateCode =?2 ")
    int deleteTeamGuidance(int teamId, String guidanceCode);
    //  根据模板编码更改团队模板对应表
    @Modifying
    @Query("update DoctorTeamGuidanceTemplate t set t.del = 0 where t.teamId = ?1 and t.teamTemplateCode =?2 ")
    int modifyTeamGuidance(int teamId, String title);
    //  每给居民发送一次团队指导，使用数量加1
    @Modifying
    @Query("update DoctorTeamGuidanceTemplate t set t.useTimes = t.useTimes+1 where t.del = 1 and t.teamId = ?1 and t.teamTemplateCode =?2 ")
    int countSend(int teamId,String guidanceCode);
}

patient-co-wlyy/src/main/java/com/yihu/wlyy/service/app/consult/ConsultTeamService.java

@@ -934,7 +934,7 @@ public class ConsultTeamService extends ConsultService {
                JSONObject jsonArticle = new JSONObject();
                jsonArticle.put("doctorName", ct.getDoctorName()!=null?ct.getDoctorName():"");
                jsonArticle.put("content", article.getSummary());
                jsonArticle.put("content", article.getSummary()!=null?article.getSummary():"");
                jsonArticle.put("czrq", article.getCzrq() != null ? DateUtil.dateToStr(article.getCzrq(), DateUtil.YYYY_MM_DD_HH_MM) : "");
                content += "医生" + (jsonArticle.get("doctorName") != null ? jsonArticle.get("doctorName").toString() : "")

patient-co-wlyy/src/main/java/com/yihu/wlyy/service/template/DoctorTeamGuidanceService.java

@@ -0,0 +1,271 @@
package com.yihu.wlyy.service.template;
import com.yihu.wlyy.entity.doctor.profile.Doctor;
import com.yihu.wlyy.entity.patient.Patient;
import com.yihu.wlyy.entity.patient.PatientHealthGuidance;
import com.yihu.wlyy.entity.template.DoctorGuidanceTemp;
import com.yihu.wlyy.entity.template.DoctorTeamGuidanceDetail;
import com.yihu.wlyy.entity.template.DoctorTeamGuidanceTemplate;
import com.yihu.wlyy.logs.BusinessLogs;
import com.yihu.wlyy.repository.doctor.DoctorDao;
import com.yihu.wlyy.repository.patient.PatientDao;
import com.yihu.wlyy.repository.template.DoctorGuidanceTempDao;
import com.yihu.wlyy.repository.template.DoctorTeamGuidanceDetailDao;
import com.yihu.wlyy.repository.template.DoctorTeamGuidanceTemplateDao;
import com.yihu.wlyy.service.BaseService;
import com.yihu.wlyy.service.app.consult.ConsultService;
import com.yihu.wlyy.service.app.health.PatientHealthGuidanceService;
import com.yihu.wlyy.util.CommonUtil;
import io.swagger.models.auth.In;
import org.apache.commons.lang3.StringUtils;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import javax.transaction.Transactional;
import java.util.*;
/**
 * Created by Reece on 2017/6/8.
 */
@Service
@Transactional
public class DoctorTeamGuidanceService extends BaseService {
    @Autowired
    private DoctorTeamGuidanceTemplateDao doctorTeamGuidanceTemplateDao;
    @Autowired
    private DoctorTeamGuidanceDetailDao doctorTeamGuidanceDetailDao;
    @Autowired
    private DoctorGuidanceTempDao doctorGuidanceTempDao;
    @Autowired
    private DoctorDao doctorDao;
    @Autowired
    private PatientDao patientDao;
    @Autowired
    private PatientHealthGuidanceService patientHealthGuidanceService;
    @Autowired
    private ConsultService consultService;
    /**
     * 新增团队指导模板
     *
     * @param title
     * @param teams
     * @param content
     * @param images
     */
    public void saveTeamGuidance(String doctor, String title, JSONArray teams, String content, String images) throws Exception {
        String templateCode = getCode();
        String image = "";
        if (StringUtils.isNotEmpty(images)) {
//            只限本地路径上传到FastDFS
            image = CommonUtil.copyTempImage(images);
            System.out.println("images =====>" + image);
        } else {
//            只有新增的时候才必须传地址
            throw new Exception("新增图片为空！");
        }
        for (Object team : teams) {
            JSONObject teamJson = new JSONObject(team.toString());
            int teamId = teamJson.getInt("teamId");
            String teamName = teamJson.getString("teamName");
            //             团队内标题排重
            List<DoctorTeamGuidanceTemplate> teamGuidanceTemplates = doctorTeamGuidanceTemplateDao.distinctByTeamTitle(title, teamId);
            if (teamGuidanceTemplates.size() == 0) {
                DoctorTeamGuidanceTemplate doctorTeamGuidanceTemplate = new DoctorTeamGuidanceTemplate();
                doctorTeamGuidanceTemplate.setCreater(doctor);
                doctorTeamGuidanceTemplate.setCreateTime(new Date());
                doctorTeamGuidanceTemplate.setDel(1);
                doctorTeamGuidanceTemplate.setTeamId(teamId);
                doctorTeamGuidanceTemplate.setTeamName(teamName);
                doctorTeamGuidanceTemplate.setTitle(title);
                doctorTeamGuidanceTemplate.setTeamTemplateCode(templateCode);
                doctorTeamGuidanceTemplate.setUseTimes(0);
                doctorTeamGuidanceTemplateDao.save(doctorTeamGuidanceTemplate);
            } else {
                throw new Exception(teamName + "：团队标题重复!");
            }
        }
//            团队内标题不重复保存到团队模板详情表团队模板表
        DoctorTeamGuidanceDetail doctorTeamGuidanceDetail = new DoctorTeamGuidanceDetail();
        doctorTeamGuidanceDetail.setCode(templateCode);
        doctorTeamGuidanceDetail.setTitle(title);
        doctorTeamGuidanceDetail.setCreater(doctor);
        doctorTeamGuidanceDetail.setContent(content);
        doctorTeamGuidanceDetail.setCreateTime(new Date());
        doctorTeamGuidanceDetail.setImagesUrl(image);
        doctorTeamGuidanceDetailDao.save(doctorTeamGuidanceDetail);
    }
    /**
     * 修改团队模板
     *
     * @param guidanceCode
     * @param title
     * @param teams
     * @param content
     * @param images
     * @throws Exception
     */
    public void modifyTeamGuidance(String doctor, int saveAsGuidance, String guidanceCode, String title, JSONArray teams, String content, String images) throws Exception {
//        图片地址需要处理
        String image = "";
        if (StringUtils.isNotEmpty(images)) {
            image = validateImages(images);
        }
        switch (saveAsGuidance) {
            case 1:
                //      保存为个人模板
                DoctorGuidanceTemp doctorGuidanceTemp = new DoctorGuidanceTemp();
                doctorGuidanceTemp.setCode(getCode());
                doctorGuidanceTemp.setImagesUrl(image);
                doctorGuidanceTemp.setCreateTime(new Date());
                doctorGuidanceTemp.setContent(content);
                doctorGuidanceTemp.setModelName(title);
                doctorGuidanceTemp.setOwner(doctor);
                doctorGuidanceTemp.setLastTime(new Date());
                doctorGuidanceTemp.setSendTimes(0);
                doctorGuidanceTempDao.save(doctorGuidanceTemp);
            case 0:
//                直接修改团队模板后修改模板团队对应表
                doctorTeamGuidanceDetailDao.modifyTeamGuidanceDetail(title, content, image, guidanceCode);
                for (Object team : teams) {
                    JSONObject teamJson = new JSONObject(team.toString());
                    int teamId = teamJson.getInt("teamId");
//                    团队内模板标题要去重复（去掉自身）
                    List<DoctorTeamGuidanceTemplate> list = doctorTeamGuidanceTemplateDao.distinctByTeamTitle(title, teamId);
                    if (list.size()==0){
                        doctorTeamGuidanceTemplateDao.modifyTeamGuidance(teamId, title);
                    }
                }
                break;
        }
    }
    /**
     * 根据医生所属的单个团队获取团队模板列表
     *
     * @param teamId
     * @param pageNo
     * @param pageSize
     * @return
     * @throws Exception
     */
    public List getTeamGuidanceList(int teamId, int pageNo, int pageSize) throws Exception {
        Sort sort = new Sort(Sort.Direction.DESC, "createTime");
        PageRequest request = new PageRequest(pageNo, pageSize, sort);
        List<DoctorTeamGuidanceTemplate> listGuidances = doctorTeamGuidanceTemplateDao.findGuidanceByTeamId(teamId, request);
        List list = new ArrayList();
        for (DoctorTeamGuidanceTemplate guidance : listGuidances) {
            Map map = new HashMap();
            String title = guidance.getTitle();
            int useTimes = guidance.getUseTimes();
            String teamTemplateCode = guidance.getTeamTemplateCode();
            map.put("teamTemplateCode", teamTemplateCode);
            map.put("title", title);
            map.put("useTimes", useTimes);
            list.add(map);
        }
        return list;
    }
    /**
     * 根据团队模板编码获取单个 有效的 模板详情
     *
     * @param guidanceCode
     * @return
     * @throws Exception
     */
    public DoctorTeamGuidanceDetail getTeamGuidanceDetail(String guidanceCode) throws Exception {
        DoctorTeamGuidanceDetail guidanceDetail = doctorTeamGuidanceDetailDao.findGuidanceDetail(guidanceCode);
        return guidanceDetail;
    }
    /**
     * 删除团队所属的团队模板
     *
     * @param teamId
     * @param guidanceCode
     * @throws Exception
     */
    public void deleteTeamGuidance(int teamId, String guidanceCode) throws Exception {
        doctorTeamGuidanceTemplateDao.deleteTeamGuidance(teamId, guidanceCode);
    }
    /**
     * 给居民发送团队模板
     *
     * @param accessToken
     * @param patient
     * @param content
     * @param guidanceCode
     * @param images
     * @throws Exception
     */
    public void sendTeamGuidance(String accessToken, String dc, String patient, String content, String guidanceCode, String images, int teamId) throws Exception {
        String image = "";
        if (StringUtils.isNotEmpty(images)) {
            image = validateImages(images);
        }
        PatientHealthGuidance guidance = new PatientHealthGuidance();
        guidance.setContent(content);
        guidance.setDoctor(dc);
        guidance.setPatient(patient);
        Doctor doctor = doctorDao.findByCode(dc);
        guidance.setImages(image);
        // 保存
        if (patientHealthGuidanceService.add(guidance, accessToken) != null) {
            String sendImgs = "";
            if (StringUtils.isNotBlank(images)) {
                sendImgs = images;
            }
            Patient p = patientDao.findByCode(patient);
            String imcotent = "{\"title\":\"健康指导\",\"type\":2,\"id\":\"" + guidance.getId() + "\",\"img\":\"" + sendImgs + "\",\"content\":\"" + CommonUtil.getSubString(guidance.getContent(), 0, 30) + "\"}";
            consultService.sendMucMessageBySingnType(dc, doctor.getName(), patient, imcotent, "4", p.getName());
            BusinessLogs.info(BusinessLogs.BusinessType.guidance, dc, patient, new JSONObject(guidance));
            //发送成功记录模板发送次数
            doctorTeamGuidanceTemplateDao.countSend(teamId, guidanceCode);
        }
    }
    /**
     * 校验图片本地路径掺杂网络路径，统一返回网路路径
     *
     * @param images
     * @throws Exception
     */
    public static String validateImages(String images) throws Exception {
        String imageUrls = "";
        String imageRow = "";
        String[] imgs = images.split(",");
        for (String image : imgs) {
            if (image.contains("http://")) {
                imageUrls += image + ",";
            } else {
                try {
                    imageRow += CommonUtil.copyTempImage(image) + ",";
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            images += imageUrls + imageRow;
        }
        images = images.substring(0, images.length() - 1);
        return images;
    }
}

patient-co-wlyy/src/main/java/com/yihu/wlyy/web/BaseController.java

@@ -43,6 +43,24 @@ public class BaseController {
        }
    }
    /**
     * 获取被代理人的code
     * @return
     */
    public String getRepresentedUID() {
        try {
            String userAgent = request.getHeader("userAgent");
            if (StringUtils.isEmpty(userAgent)) {
                userAgent = request.getHeader("User-Agent");
            }
            JSONObject json = new JSONObject(userAgent);
            return json.getString("represented");
        } catch (Exception e) {
            return null;
        }
    }
    /**
     * 獲取髮送請求用戶的uid
     *

patient-co-wlyy/src/main/java/com/yihu/wlyy/web/doctor/health/DoctorTeamGuidanceController.java

@@ -1,168 +0,0 @@
package com.yihu.wlyy.web.doctor.health;
import com.yihu.wlyy.entity.doctor.team.admin.AdminTeam;
import com.yihu.wlyy.entity.patient.PatientHealthStandard;
import com.yihu.wlyy.health.entity.DevicePatientHealthIndex;
import com.yihu.wlyy.service.app.health.PatientHealthIndexService;
import com.yihu.wlyy.service.app.team.AdminTeamService;
import com.yihu.wlyy.util.DateUtil;
import com.yihu.wlyy.util.SystemConf;
import com.yihu.wlyy.web.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
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 java.util.*;
/**
 * 医生端、后端团队指导模板控制类
 */
@Controller
@RequestMapping(value = "/doctor/team/guidance", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
@Api(description = "医生端&后端团队指导模板")
public class DoctorTeamGuidanceController extends BaseController {
    @Autowired
    private AdminTeamService adminTeamService;
    /**
     * 获取医生所属的所有团队
     *
     * @return
     */
    @RequestMapping(value = "/getDoctorTeams", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation("获取医生所属的所有团队")
    public String getHealthIndexHistory() {
        try {
            String doctorCode = getUID();
            List<AdminTeam> doctorTeams = adminTeamService.getDoctorTeams(doctorCode);
            List teamList = new ArrayList();
            for (AdminTeam AdminTeam : doctorTeams) {
                Map map = new HashMap();
                String teamName = AdminTeam.getName();
                Long teamId = AdminTeam.getId();
                map.put("teamName", teamName);
                map.put("teamId", teamId);
                teamList.add(map);
            }
            return write(200, "获取医生所属团队成功！", "teamList", teamList);
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
    /**
     * 根据医生所属的单个团队获取团队模板列表
     * @param teamId
     * @return
     */
    @RequestMapping(value = "/getTeamGuidanceList", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation("获取单个团队模板列表")
    public String getTeamGuidanceList(@RequestParam Long teamId,
                                      @RequestParam int pageNo,
                                      @RequestParam int pageSize) {
        try {
            String doctorCode = getUID();
            List<AdminTeam> doctorTeams = adminTeamService.getDoctorTeams(doctorCode);
            return write(200, "获取团队模板列表成功！", "templateList", "");
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
    /**
     * 获取医生所属的所有团队
     *
     * @return
     */
    @RequestMapping(value = "/getTeamGuidanceDetail", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation("获取医生所属的所有团队")
    public String getTeamGuidanceDetail() {
        try {
            String doctorCode = getUID();
            List<AdminTeam> doctorTeams = adminTeamService.getDoctorTeams(doctorCode);
            List teamList = new ArrayList();
            for (AdminTeam AdminTeam : doctorTeams) {
                Map map = new HashMap();
                String teamName = AdminTeam.getName();
                Long teamId = AdminTeam.getId();
                map.put("teamName", teamName);
                map.put("teamId", teamId);
                teamList.add(map);
            }
            return write(200, "获取医生所属成功！", "teamList", teamList);
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
    /**
     * 获取医生所属的所有团队
     *
     * @return
     */
    @RequestMapping(value = "/saveOrModifyTeamGuidance", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation("获取医生所属的所有团队")
    public String saveOrModifyTeamGuidance() {
        try {
            String doctorCode = getUID();
            List<AdminTeam> doctorTeams = adminTeamService.getDoctorTeams(doctorCode);
            List teamList = new ArrayList();
            for (AdminTeam AdminTeam : doctorTeams) {
                Map map = new HashMap();
                String teamName = AdminTeam.getName();
                Long teamId = AdminTeam.getId();
                map.put("teamName", teamName);
                map.put("teamId", teamId);
                teamList.add(map);
            }
            return write(200, "获取医生所属成功！", "teamList", teamList);
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
    /**
     * 获取医生所属的所有团队
     *
     * @return
     */
    @RequestMapping(value = "/deleteTeamGuidance", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation("获取医生所属的所有团队")
    public String deleteTeamGuidance() {
        try {
            String doctorCode = getUID();
            List<AdminTeam> doctorTeams = adminTeamService.getDoctorTeams(doctorCode);
            List teamList = new ArrayList();
            for (AdminTeam AdminTeam : doctorTeams) {
                Map map = new HashMap();
                String teamName = AdminTeam.getName();
                Long teamId = AdminTeam.getId();
                map.put("teamName", teamName);
                map.put("teamId", teamId);
                teamList.add(map);
            }
            return write(200, "获取医生所属成功！", "teamList", teamList);
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
}

patient-co-wlyy/src/main/java/com/yihu/wlyy/web/doctor/template/DoctorTeamGuidanceController.java

@@ -0,0 +1,239 @@
package com.yihu.wlyy.web.doctor.template;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.wlyy.entity.doctor.team.admin.AdminTeam;
import com.yihu.wlyy.entity.patient.PatientHealthStandard;
import com.yihu.wlyy.entity.template.DoctorTeamGuidanceDetail;
import com.yihu.wlyy.health.entity.DevicePatientHealthIndex;
import com.yihu.wlyy.service.app.health.PatientHealthIndexService;
import com.yihu.wlyy.service.app.team.AdminTeamService;
import com.yihu.wlyy.service.template.DoctorTeamGuidanceService;
import com.yihu.wlyy.util.DateUtil;
import com.yihu.wlyy.util.SystemConf;
import com.yihu.wlyy.web.BaseController;
import com.yihu.wlyy.web.WeixinBaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
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 java.util.*;
/**
 * 医生端、后端团队指导模板控制类
 */
@Controller
@RequestMapping(value = "/doctor/team/guidance", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
@Api(description = "医生端&后端团队指导模板")
public class DoctorTeamGuidanceController extends WeixinBaseController {
    @Autowired
    private AdminTeamService adminTeamService;
    @Autowired
    private DoctorTeamGuidanceService doctorTeamGuidanceService;
    @Autowired
    private ObjectMapper objectMapper;
    /**
     * 获取医生所属的所有团队
     *
     * @return
     */
    @RequestMapping(value = "/getDoctorTeams", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation("获取医生所属的所有团队")
    public String getHealthIndexHistory() {
        try {
            String doctorCode = getUID();
            List<AdminTeam> doctorTeams = adminTeamService.getDoctorTeams(doctorCode);
            List teamList = new ArrayList();
            for (AdminTeam AdminTeam : doctorTeams) {
                Map map = new HashMap();
                String teamName = AdminTeam.getName();
                Long teamId = AdminTeam.getId();
                map.put("teamName", teamName);
                map.put("teamId", teamId);
                teamList.add(map);
            }
            return write(200, "获取医生所属团队成功！", "teamList", teamList);
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
    /**
     * 根据医生所属的单个团队获取团队模板列表
     *
     * @param teamId
     * @return
     */
    @RequestMapping(value = "/getTeamGuidanceList", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation("获取单个团队模板列表")
    public String getTeamGuidanceList(@RequestParam int teamId,
                                      @RequestParam int pageNo,
                                      @RequestParam int pageSize) {
        try {
            List list = doctorTeamGuidanceService.getTeamGuidanceList(teamId, pageNo-1, pageSize);
            return write(200, "获取团队模板列表成功！", "templateList", list);
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
    /**
     * 根据团队模板编码获取单个模板详情
     *
     * @return
     */
    @RequestMapping(value = "/getTeamGuidanceDetail", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation("获取单个模板详情")
    public String getTeamGuidanceDetail(
            @ApiParam(value = "团队模板编码")
            @RequestParam String teamTemplateCode) {
        try {
            DoctorTeamGuidanceDetail guidanceDetail = doctorTeamGuidanceService.getTeamGuidanceDetail(teamTemplateCode);
            return write(200, "获取模板详情成功！", "guidanceDetail", guidanceDetail);
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
    /**
     * 新增团队模板
     *
     * @param title    模板标题要排重，团队内不可重复
     * @param teamInfo 该模板所属的团队ID及名称 可能会有多个
     * @param content  模板内容，前端限10000，后端无限制
     * @param images   多图以，分隔，取值1-9图,
     * @return
     */
    @RequestMapping(value = "/saveTeamGuidance", method = RequestMethod.POST)
    @ResponseBody
    @ApiOperation("新增团队模板")
    public String saveTeamGuidance(
            @ApiParam(value = "团队模板标题")
            @RequestParam String title,
            @ApiParam(value = "所属团队ID及名称json串", defaultValue = "[{\"teamName\":\"一农\",\"teamId\":212},{\"teamName\":\"一\",\"teamId\":21}]")
            @RequestParam String teamInfo,
            @ApiParam(value = "模板内容")
            @RequestParam String content,
            @ApiParam(value = "图片路径")
            @RequestParam String images
    ) {
        try {
//            前端参数校验
            String doctor = getUID();
            JSONArray teams = new JSONArray(teamInfo);
            doctorTeamGuidanceService.saveTeamGuidance(doctor, title, teams, content, images);
            return write(200, "保存团队模板成功！");
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
    /**
     * 修改团队模板
     *
     * @param saveAsGuidance 团队模板是否保存为个人模板 0否 1是
     * @param title          模板标题要排重，团队内不可重复
     * @param teamInfo       该模板所属的团队ID及名称 可能会有多个
     * @param content        模板内容，前端限10000，后端无限制
     * @param images         多图以，分隔，取值0-9图,
     * @return
     */
    @RequestMapping(value = "/modifyTeamGuidance", method = RequestMethod.POST)
    @ResponseBody
    @ApiOperation("修改团队模板")
    public String modifyTeamGuidance(
            @ApiParam(value = "团队模板团队模板是否保存为个人模板", defaultValue = "0")
            @RequestParam int saveAsGuidance,
            @ApiParam(value = "要修改的团队模板编号")
            @RequestParam String guidanceCode,
            @ApiParam(value = "团队模板标题")
            @RequestParam String title,
            @ApiParam(value = "所属团队ID及名称json串", defaultValue = "[{\"teamName\":\"一农\",\"teamId\":212},{\"teamName\":\"一\",\"teamId\":21}]")
            @RequestParam(required = false) String teamInfo,
            @ApiParam(value = "模板内容")
            @RequestParam String content,
            @ApiParam(value = "图片路径")
            @RequestParam(required = false) String images) {
        try {
            String doctor = getUID();
            JSONArray teams = new JSONArray(teamInfo);
            doctorTeamGuidanceService.modifyTeamGuidance(doctor, saveAsGuidance, guidanceCode, title, teams, content, images);
            return write(200, "修改团队模板成功！");
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
    /**
     * 删除团队所属的团队模板
     *
     * @param teamId
     * @param guidanceCode
     * @return
     */
    @RequestMapping(value = "/deleteTeamGuidance", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation("删除团队所属的团队模板")
    public String deleteTeamGuidance(
            @ApiParam(value = "团队ID")
            @RequestParam int teamId,
            @ApiParam(value = "团队模板编码")
            @RequestParam String guidanceCode) {
        try {
            doctorTeamGuidanceService.deleteTeamGuidance(teamId, guidanceCode);
            return write(200, "删除模板成功！");
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
    /**
     * 发送团队模板给居民
     *
     * @param patient
     * @param content
     * @param guidanceCode
     * @param images
     * @return
     */
    @RequestMapping(value = "/sendTeamGuidance", method = RequestMethod.POST)
    @ResponseBody
    @ApiOperation("发送团队模板给居民")
    public String sendTeamGuidance(
            @ApiParam(value = "要发送的居民code")
            @RequestParam String patient,
            @ApiParam(value = "团队模板内容")
            @RequestParam String content,
            @ApiParam(value = "团队id")
            @RequestParam int teamId,
            @ApiParam(value = "团队模板code")
            @RequestParam String guidanceCode,
            @ApiParam(value = "团队模板图片")
            @RequestParam(required = false) String images) {
        try {
            String accessToken = getAccessToken();
            String doctor = getUID();
            doctorTeamGuidanceService.sendTeamGuidance(accessToken,doctor,patient,content, guidanceCode,images,teamId);
            return write(200, "发送成功！");
        } catch (Exception e) {
            return invalidUserException(e, -1, e.getMessage());
        }
    }
}