package com.ui.ctrl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.ui.cloud.task.ProjectsLoader;
import com.ui.contants.AlarmGroupContants;
import com.ui.contants.HttpUriContants;
import com.ui.ctrl.util.ReleaseCheck;
import com.ui.http.HttpRestClient;
import com.ui.model.BaseResponse;
import com.ui.model.domain.BuildMessage;
import com.ui.model.req.*;
import com.ui.project.Project;
import com.ui.project.ProjectEnvironment;
import com.ui.project.ProjectMutex;
import com.ui.project.ProjectOnlineResponse;
import lombok.Data;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpSession;
import java.text.SimpleDateFormat;
import java.util.*;

@RestController
@RequestMapping("project")
public class ProjectBuildCtrl {
    Logger log = LoggerFactory.getLogger(ProjectBuildCtrl.class);
    //需要特殊处理的项目
    private final List<String> lb_proejct_list=new ArrayList<String>() {{
        //add("yoho-search-service");
        //add("uic");
    }};


    @Autowired
    private ProjectsLoader projectsLoader;

    @Autowired
    private HttpRestClient httpRestClient;

    @Autowired
    private ReleaseCheck releaseCheck;

    @RequestMapping("/toOm")
    public ModelAndView toOm() {
        return new ModelAndView("project/om");
    }

    @RequestMapping("/toNewOm")
    public ModelAndView toOmNew() {
        return new ModelAndView("project/newOm");
    }

    @RequestMapping("/toNode")
    public ModelAndView toNode() {
        return new ModelAndView("project/node");
    }

    @RequestMapping("/toProject")
    public ModelAndView toProject(Model model,String workJobId) {
        if(StringUtils.isNotBlank(workJobId)){
            BaseResponse response = httpRestClient.defaultGet(HttpUriContants.GET_RELEASEWORKJOB_ID + "?id=" + workJobId, BaseResponse.class);
            if(response!=null&&response.getCode()==200&&response.getData()!=null){
                Map map=(Map)response.getData();
                List<String> releaseWorkJob_environment_list=new ArrayList<>();
                String releaseWorkJob_environment=(String)(map.get("environment")==null?"":map.get("environment"));
                int releaseWorkJob_enviCount=0;
                if(releaseWorkJob_environment!=null&&releaseWorkJob_environment.length()>0&&!releaseWorkJob_environment.endsWith(",")){
                    releaseWorkJob_environment+=",";
                }
                for(String tmp:releaseWorkJob_environment.split(",")){
                    if(tmp!=null&&tmp.trim().length()>0){
                        releaseWorkJob_enviCount++;
                        releaseWorkJob_environment_list.add(tmp.trim());
                    }
                }

                String releaseWorkJob_project =  map.get("project")==null?"":(String)map.get("project");
                if(releaseWorkJob_project!=null&&releaseWorkJob_project.length()>0&&!releaseWorkJob_project.endsWith(",")){
                    releaseWorkJob_project += ",";
                }
                model.addAttribute("releaseWorkJob_enviCount", releaseWorkJob_enviCount);
                model.addAttribute("releaseWorkJob_environment", releaseWorkJob_environment);
                model.addAttribute("releaseWorkJob_branch", map.get("branch")==null?"":(String)map.get("branch"));
                model.addAttribute("releaseWorkJob_project",releaseWorkJob_project);
                model.addAttribute("releaseWorkJob_id", workJobId);
                model.addAttribute("releaseWorkJob_environment_list", releaseWorkJob_environment_list);
            }

        }
        model.addAttribute("environments", Arrays.asList(projectsLoader.getProjectOnline().getJavaEnvAll().split(",")));
        ModelAndView mv=new ModelAndView("project/project");
        return mv;
    }

    @RequestMapping("/toHistory")
    public ModelAndView toHistory(Model model) {
        ProjectOnlineResponse projectOnline=projectsLoader.getProjectOnline(true);
        model.addAttribute("environments", Arrays.asList(projectOnline.getJavaEnvAll().split(",")));

        model.addAttribute("projects", projectOnline.getJavaList());

        return new ModelAndView("project/history");
    }

    /**
     * 获取所有项目
     *
     * @return
     */
    @RequestMapping(value = "getProjects", method = RequestMethod.POST)
    @ResponseBody
    public String getProjects() {
        try {
            return JSONArray.toJSON(projectsLoader.getProjectOnline().getJavaList()).toString();
        } catch (Exception ex) {
            return "failed";
        }
    }

    /**
     * 获取项目的发布环境
     * 不同项目取交集
     *
     * @return
     */
    @RequestMapping(value = "getJavaProjectEnvList")
    @ResponseBody
    public List<String> getJavaProjectEnvList(String projects) {
        List<String> projArray=new ArrayList<>();
        for(String tmp:projects.split(",")){
            if(StringUtils.isNotBlank(tmp)){
                projArray.add(tmp);
            }
        }
        return getJavaProjectEnvList(projArray);
    }

    public List<String> getJavaProjectEnvList(List<String> projArray) {
        Map<String,Project> javaMap=projectsLoader.getProjectOnline().getJavaMap();
        List<String> envs=new ArrayList<>();
        for(int i=0;i<projArray.size();i++){
            List<String> ls= javaMap.get(projArray.get(i)).getSupportEnvList();
            if(i==0){
                envs.addAll(ls);
            }else{
                envs.retainAll(ls);
            }
        }
        return envs;
    }

    /**
     * 校验tag
     *
     * @return
     */
    @RequestMapping(value = "checkTag", method = RequestMethod.POST)
    @ResponseBody
    public String checkTag(String projects, String tag, String enviromment) {
        Map<String, String> map = new HashMap<>();
        map.put("projects", projects);
        map.put("tag", tag);
        return httpRestClient.get(ProjectEnvironment.getUrl(enviromment) + "checkTag", String.class, map);

    }

    /**
     * 发布前校验
     *
     * @return
     */
    @RequestMapping(value = "check")
    @ResponseBody
    public BaseResponse check(String projects, String branch, String environment,String workid,HttpSession httpSession) {
        BaseResponse rtnResponse=releaseCheck.check(workid,httpSession);
        if(200!=rtnResponse.getCode()){
            return rtnResponse;
        }
        //项目冲突的校验
        List<Object> checkRtn= ProjectMutex.checkMutex(projects);
        boolean mutex=(Boolean)checkRtn.get(0);
        if(mutex){
            rtnResponse.setCode(201);
            rtnResponse.setMessage((String)checkRtn.get(1));
            return rtnResponse;
        }

        Map<String,String> map = new HashMap<>();
        if (!("master".equals(branch) || "test".equals(branch) || "dev".equals(branch) )) {
            map.clear();
            map.put("projects", projects);
            map.put("branch", branch);
            String checkBranchResult= httpRestClient.get(ProjectEnvironment.getUrl(environment) + "checkBranch", String.class, map);
            if(!"1".equals(checkBranchResult)){
                rtnResponse.setCode(201);
                rtnResponse.setMessage("分支不存在"+branch+",result :"+checkBranchResult);
                return rtnResponse;
            }
        }
        return rtnResponse;


    }

    @RequestMapping(value = "tobuildpage")
    @ResponseBody
    public ModelAndView tobuildpage(String messageid, String project, String environment, String operate, String branch, String rollbackfile, Model model) {
        model.addAttribute("messageid", messageid);
        model.addAttribute("project", project);
        model.addAttribute("environment", environment);
        model.addAttribute("operate", operate);
        model.addAttribute("branch", branch);
        model.addAttribute("rollbackfile", rollbackfile);
        return new ModelAndView("project/single_project_build");
    }

    /**
     * 执行任务
     *
     * 修改日志：yoho-search-service项目发布或者回滚时，aws和qq需要特殊处理，
     *                先从负载均衡器卸载n-1个机器，保留一台，发布卸载的n-1台，发布，再挂载，再卸载原来一台，发布，再挂载
     * 修改时间：2017-12-28
     * 修改人：craig.qin
     *
     * 最终执行的方法是 project-boot 工程里的JavaBuildCtrl(web) -> build.do
     * 执行的ip是http:/
     * @return
     */
    @RequestMapping(value = "build", method = RequestMethod.POST)
    public ModelAndView build(String project_name, String environment_name, String operate_name, String branch_name, String rollbackfile_name,String workid_name, Model model, HttpSession session) {
        try {
            User user = (User) session.getAttribute("user");
            /*Map<String,String> map = new HashMap<>();
            if (StringUtils.equals("Deploy",operate_name) && !StringUtils.equals("release0",workid_name)){//查询用户是否有工单处理权限
                map.put("id",workid_name);
                map.put("user",user.getName());
                BaseResponse baseResponse = httpRestClient.defaultGet(HttpUriContants.UPDATE_JOB_BY_OPERATOR,BaseResponse.class,map);
                if (baseResponse.getCode() != 200){
                    model.addAttribute("environment_name", baseResponse.getMessage());
                    return new ModelAndView("project/project_build");
                }
            }*/

            BaseResponse checkResponse=releaseCheck.checkAndUpdate(workid_name,operate_name,user.getName());
            if(200!=checkResponse.getCode()){
                model.addAttribute("environment_name", checkResponse.getMessage());
                return new ModelAndView("project/project_build");
            }

            //发布的时候，启动一个线程 ，更新项目的tag
            final String projectNamesForUpdateTag=project_name;
            new Thread(() -> {
                try {
                    httpRestClient.defaultGet(HttpUriContants.JAVA_RESTART_UPDATE_HOST_TAGS+"?projectNames="+projectNamesForUpdateTag,BaseResponse.class);
                } catch (Exception e) {
                    log.error("project build update tags error {}",e);
                }

            }).start();

            List<String> projectList=Arrays.asList(project_name.split(","));
            //把要发布的项目重新组合，其中特殊情况的项目，先拿出来传递到前台，其余的普通项目直接发布
            List<String> specialProjectLb=new ArrayList<>();
            if(("aws".equals(environment_name)||"qcloud".equals(environment_name))){
                project_name="";
                for(String str:projectList){
                    if(StringUtils.isNotBlank(str)){
                        if(lb_proejct_list.contains(str)){
                            specialProjectLb.add(str);
                            continue;
                        }
                        if(project_name.length()>0){
                            project_name += ",";
                        }
                        project_name += str ;
                    }
                }
            }
            model.addAttribute("specialProjectLbList", JSONArray.parseArray(JSON.toJSONString(specialProjectLb)));

            String messageids = "";
            List<BuildMessage> list = new ArrayList<>();
            if(StringUtils.isNotBlank(project_name)){
                BuildRequest buildRequest = new BuildRequest();
                //分支名称
                buildRequest.setBranch(branch_name);
                //登陆用户
                buildRequest.setUser(user.getName());
                //发布环境
                buildRequest.setEnvironment(environment_name);
                //回滚文件名称
                buildRequest.setRollbackfile(rollbackfile_name);
                //操作类型
                buildRequest.setOperate(operate_name);
                //关联工单
                buildRequest.setWorkid(workid_name);

                if ("Deploy".equals(operate_name)) {
                    //不包含特殊项目，直接走原来的发布
                    messageids=deploy(project_name,environment_name,buildRequest,list,messageids);
                } else {
                    buildRequest.setProject(project_name);
                    messageids=rollback(environment_name, buildRequest, list, messageids);
                }
            }

            model.addAttribute("environment_name", environment_name);
            model.addAttribute("operate_name", operate_name);
            model.addAttribute("branch_name", branch_name);
            model.addAttribute("rollbackfile_name", rollbackfile_name);
            model.addAttribute("messageids", messageids);
            model.addAttribute("messageList", list);
            model.addAttribute("workid_name",workid_name);
        } catch (Exception ex) {
        }
        return new ModelAndView("project/project_build");
    }

    @RequestMapping(value ="/buildProjectWithIPs", method = RequestMethod.POST)
    @ResponseBody
    public BaseResponse<?> buildProjectWithIPs(HttpSession session, String project_name,String ips, String environment_name, String operate_name, String branch_name, String rollbackfile_name,String workid_name){
        BaseResponse response = new BaseResponse();
        try{
            User user = (User) session.getAttribute("user");
            BaseResponse checkResponse=releaseCheck.checkAndUpdate(workid_name,operate_name,user.getName());
            if(200!=checkResponse.getCode()){
                return checkResponse;
            }

            List<BuildMessage> list = new ArrayList<>();
            BuildRequest buildRequest = new BuildRequest();
            //分支名称
            buildRequest.setBranch(branch_name);
            //登陆用户
            buildRequest.setUser(user.getName());

            //设置需要发布的ip
            buildRequest.setHost(ips);

            //发布环境
            buildRequest.setEnvironment(environment_name);
            //回滚文件名称
            buildRequest.setRollbackfile(rollbackfile_name);
            //操作类型
            buildRequest.setOperate(operate_name);
            //关联工单
            buildRequest.setWorkid(workid_name);
            //项目名称
            buildRequest.setProject(project_name);

            String messageids = "";
            BuildMessage buildMessage = httpRestClient.post(ProjectEnvironment.getUrl(environment_name) + "build", buildRequest, BuildMessage.class);
            if (buildMessage != null) {
                list.add(buildMessage);
                messageids =  buildMessage.getId() + ",";
            }
            response.setData(messageids);
        }catch (Exception e){
            response.setCode(300);
            response.setMessage(e.getMessage());
        }

        return response;
    }

    @RequestMapping(value = "/deregisterHostYohoSearchService")
    @ResponseBody
    public BaseResponse deregisterHostYohoSearchService(String project,String environment_name,String instIds){
        Map<String, String> map=new HashMap<>();
        map.put("cloudType",environment_name);
        map.put("instIds",instIds);
        map.put("project",project);
        return httpRestClient.defaultGet("/lb/deregisterHostFromLb/yohoSearchService",BaseResponse.class,map);
    }

    @RequestMapping(value = "/registerHostYohoSearchService")
    @ResponseBody
    public BaseResponse registerHostYohoSearchService(String project,String environment_name,String instIds){
        Map<String, String> map=new HashMap<>();
        map.put("cloudType",environment_name);
        map.put("instIds",instIds);
        map.put("project",project);
        return httpRestClient.defaultGet("/lb/registerHostFromLb/yohoSearchService",BaseResponse.class,map);
    }

    @RequestMapping(value = "/getLbInfoYohoSearchService")
    @ResponseBody
    public BaseResponse getLbInfoYohoSearchService(String project,String environment_name){
        Map<String, String> map=new HashMap<>();
        map.put("cloudType",environment_name);
        map.put("project",project);
        return httpRestClient.defaultGet("/lb/getLb/yohoSearchService",BaseResponse.class,map);
    }

    /**
     * 特殊项目发布之前检查lb的情况
     * @param project
     * @param environment_name
     * @return
     */
    @RequestMapping(value = "/checkSpecialProjectLbInfoBeforeBuild")
    @ResponseBody
    public BaseResponse checkSpecialProjectLbInfoBeforeBuild(String project,String environment_name,String branch_name,String workid_name,String operate_name,String rollbackfile_name){
        LbResult lbResult=new LbResult();
        lbResult.setCurrentProject(project);
        lbResult.setEnvironmentName(environment_name);
        lbResult.setBranch(branch_name);
        lbResult.setWorkIdName(workid_name);
        lbResult.setOperateName(operate_name);
        lbResult.setRollbackfileName(rollbackfile_name);

        BaseResponse response = this.getLbInfoYohoSearchService(project,environment_name);
        if(response!=null&&response.getCode()==200){
            Map<String,String> hostIdAndIpMap=(Map<String,String>)response.getData();
            //负载均衡只有一台机器的情况，就不拿掉了 ，直接发布吧
            if(hostIdAndIpMap.size()<=1){
                lbResult.setOnlyOneHost("1");
                lbResult.setMsg("负载均衡最多只有一台机器,直接发布！");
            }else{
                lbResult.setOnlyOneHost("2");
                //保留的机器和需要卸载（挂载）的机器
                lbResult.setMsg("负载均衡有多个机器，走特殊发布流程！");
                int index=0;
                for(String id:hostIdAndIpMap.keySet()){
                    if(index==0){
                        lbResult.setKeepId(id);
                        lbResult.setKeepNum(1);
                        lbResult.setKeepIp(hostIdAndIpMap.get(id));
                    }else{
                        if(lbResult.getChangeIds().length()>0){
                            lbResult.setChangeIds(lbResult.getChangeIds()+",");
                        }
                        lbResult.setChangeIds(lbResult.getChangeIds()+id);

                        if(lbResult.getChangeIps().length()>0){
                            lbResult.setChangeIps(lbResult.getChangeIps()+",");
                        }
                        lbResult.setChangeIps(lbResult.getChangeIps()+hostIdAndIpMap.get(id));
                    }
                    index++;
                }
                lbResult.setHostNum(index);
                lbResult.setChangeNum(index-1);
            }

            response.setData(lbResult);
        }
        return response;
    }



    @Data
    class LbResult{
        String currentProject="";
        String branch="";
        String environmentName="";
        String workIdName="";
        String operateName="";
        String rollbackfileName="";

        boolean errorFlag=false;
        String onlyOneHost="";
        String msg="";

        //保留的机器和需要卸载（挂载）的机器
        int hostNum=0;
        String keepId="";
        int keepNum=0;
        String keepIp="";
        String changeIds="";
        String changeIps="";
        int changeNum=0;
        //Map<String,String> changeHostIdAndIpMap=new LinkedHashMap<>();
    }

    private String deploy(String project_name,String environment_name,BuildRequest buildRequest,List<BuildMessage> list,String messageids){
        String[] array = project_name.split(",");
        if (array.length > 4) {
            String[] newArray = new String[]{"", "", "", ""};
            for (int i = 0; i < array.length; i++) {
                newArray[i % 4] = newArray[i % 4] + array[i] + ",";
            }
            //如上下所述，只支持长度为4。。。。。不明白
            for (String project : newArray) {
                buildRequest.setProject(project.substring(0, project.length() - 1));
                BuildMessage buildMessage = httpRestClient.post(ProjectEnvironment.getUrl(environment_name) + "build", buildRequest, BuildMessage.class);
                if (buildMessage != null) {
                    list.add(buildMessage);
                    messageids = messageids + buildMessage.getId() + ",";
                }
            }

        } else {
            for (String project : array) {
                buildRequest.setProject(project);
                BuildMessage buildMessage = httpRestClient.post(ProjectEnvironment.getUrl(environment_name) + "build", buildRequest, BuildMessage.class);
                if (buildMessage != null) {
                    list.add(buildMessage);
                    messageids = messageids + buildMessage.getId() + ",";
                }
            }
        }
        return messageids;
    }

    private String  rollback(String environment_name,BuildRequest buildRequest,List<BuildMessage> list,String messageids){
        BuildMessage buildMessage = httpRestClient.post(ProjectEnvironment.getUrl(environment_name) + "build", buildRequest, BuildMessage.class);
        if (buildMessage != null) {
            list.add(buildMessage);
            messageids = messageids + buildMessage.getId() + ",";
        }
        return messageids;
    }

    /**
     * 获取执行结果
     *
     * @param messageid
     * @return
     */
    @RequestMapping(value = "getbuildmsg", method = RequestMethod.POST)
    @ResponseBody
    public String getbuildmsg(String messageid, String project) {
        /*try {
            Map<String, String> map = new HashMap<>();
            map.put("messageid", messageid);
            map.put("project", project);

            return httpRestClient.get(ProjectEnvironment.getUrl(messageid.split("_")[0]) + "getbuildmsg", String.class, map);

        } catch (Exception ex) {
            return "failed";
        }*/
        return releaseCheck.getbuildmsg(ProjectEnvironment.getUrl(messageid.split("_")[0]) ,messageid,project);
    }

    @RequestMapping(value = "cancelBuild")
    @ResponseBody
    public String cancelBuild(String id) {
       /* try {
            Map<String, String> map = new HashMap<>();
            map.put("id", id);
            return httpRestClient.get(ProjectEnvironment.getUrl(id.split("_")[0]) + "cancelBuild", String.class, map);
        } catch (Exception ex) {
            return "failed";
        }*/
        return releaseCheck.cancelBuild(ProjectEnvironment.getUrl(id.split("_")[0]) ,id);
    }

    @RequestMapping(value = "rollbackList", method = RequestMethod.POST)
    @ResponseBody
    public String rollbackList(String project, String environment) {
        /*try {
            Map<String, String> map = new HashMap<>();
            map.put("project", project);
            map.put("environment", environment);
            return httpRestClient.get(ProjectEnvironment.getUrl(environment) + "rollbackList", String.class, map);
        } catch (Exception ex) {
            return "failed";
        }*/
        return releaseCheck.rollbackList(ProjectEnvironment.getUrl(environment) ,project,environment);
    }

    @RequestMapping("/getHistory")
    @ResponseBody
    public BaseResponse getHistory(ProjectBuildReq req) throws Exception {
        if ("all".equals(req.getEnvironment())) {
            req.setEnvironment(null);
        }
        if ("all".equals(req.getCurrentProject())) {
            req.setCurrentProject(null);
        }
        BaseResponse response = httpRestClient.defaultPost("/projectBuild/getHistory", req, BaseResponse.class);
        return response;
    }

    @RequestMapping("/projectDetectUrl")
    @ResponseBody
    public BaseResponse projectDetectUrl(String operate_name,String project,String environment) throws Exception {
        Map<String,String> map=new HashMap<>();
        map.put("project",project);
        map.put("environment",environment);
        BaseResponse response = httpRestClient.defaultGet("/javaApiDetect/projectDetectUrl", BaseResponse.class,map);
        return response;
    }

    @RequestMapping("/toRollbackByTime")
    @ResponseBody
    public ModelAndView toRollbackByTime() {
        return new ModelAndView("project/project_rollbackByTime");
    }

    @RequestMapping("/rollbackByTime")
    @ResponseBody
    public String rollbackByTime(String time, String environment) {
        Map<String, String> map = new HashMap<>();
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY,1);
        calendar.set(Calendar.MINUTE,0);
        calendar.set(Calendar.SECOND,0);

        if (StringUtils.equals("yestoday",time)){
            time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());
        }else if (StringUtils.equals("beforeYestoday",time)){
            calendar.add(Calendar.DAY_OF_YEAR,-1);
            time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());
        }
        map.put("time", time);
        map.put("environment", environment);
        return httpRestClient.get(ProjectEnvironment.getUrl(environment) + "rollbackByTime", String.class, map);
    }

    @RequestMapping("/doRollbackByTime")
    @ResponseBody
    public ModelAndView doRollbackByTime(String data, String environment, HttpSession session, Model model) {
        try {
            JSONArray jsonArray = JSONArray.parseArray(data);
            User user = (User) session.getAttribute("user");
            List<BuildMessage> list = new ArrayList<>();
            BuildRequest buildRequest = new BuildRequest();
            buildRequest.setUser(user.getName());
            buildRequest.setEnvironment(environment);
            buildRequest.setOperate("Rollback");

            String messageids = "";
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject jsonObject = jsonArray.getJSONObject(i);
                String project = jsonObject.getString("project");
                buildRequest.setProject(project);
                buildRequest.setRollbackfile(jsonObject.getString("rollbackFile"));
                BuildMessage buildMessage = httpRestClient.post(ProjectEnvironment.getUrl(environment) + "build", buildRequest, BuildMessage.class);
                if (buildMessage != null) {
                    list.add(buildMessage);
                    messageids = messageids + buildMessage.getId() + ",";
                }
            }
            model.addAttribute("environment_name", environment);
            model.addAttribute("operate_name", "Rollback");
            model.addAttribute("messageids", messageids);
            model.addAttribute("messageList", list);
        } catch (Exception ex) {
        }
        return new ModelAndView("project/project_build");


    }


    @RequestMapping("/newOm/query")
    public BaseResponse queryProjects(ProjectInfoReq req) {

        BaseResponse response = httpRestClient.defaultPost("/projectManager/query", req, BaseResponse.class);

        return response;
    }


    @RequestMapping("/newOm/save")
    public BaseResponse addProject(ProjectInfoReq req) {

        BaseResponse response = httpRestClient.defaultPost("/projectManager/add", req, BaseResponse.class);
        return response;
    }

    @RequestMapping("/newOm/del")
    public BaseResponse delProject(ProjectInfoReq req) {

        BaseResponse response = httpRestClient.defaultPost("/projectManager/del", req, BaseResponse.class);
        return response;
    }

    @RequestMapping("/newOm/build")
    public BaseResponse buildOmProject(ProjectBuildInfoReq req) {
        BaseResponse response = httpRestClient.defaultPost("/projectManager/build", req, BaseResponse.class);
        return response;
    }

    @RequestMapping("/aototest/autoTestService")
    @ResponseBody
    public BaseResponse autoTestService(String models, String branch, HttpSession session) {
        User user = (User) session.getAttribute("user");
        AutoTestReq autoTestReq = new AutoTestReq();
        String id = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()) + RandomStringUtils.randomNumeric(6);
        autoTestReq.setTaskname(id);
        autoTestReq.setEnv("5");
        autoTestReq.setModels(models.substring(0, models.length() - 1));
        autoTestReq.setBranch(branch);
        autoTestReq.setProId(0);
        autoTestReq.setVersionId(0);
        autoTestReq.setMailto(user.getEmail());
        BaseResponse baseResponse = httpRestClient.post("http://qmc.yohops.com:9999/autotest/autoTestService", autoTestReq, BaseResponse.class);
        System.out.println(id);
        return baseResponse;
    }

    @RequestMapping("/aototest/getAutoTestResult")
    @ResponseBody
    public BaseResponse getAutoTestResult(String id) {
        AutoTestReq autoTestReq = new AutoTestReq();
        autoTestReq.setTaskname(id);
        BaseResponse baseResponse = httpRestClient.post("http://qmc.yohops.com:9999/autotest/getAutoTestResult", autoTestReq, BaseResponse.class);
        return baseResponse;
    }

    @RequestMapping("/aototest/toAutoTestResult")
    public ModelAndView toAutoTestResult(String id, Model model) {
        model.addAttribute("id", id);
        return new ModelAndView("project/autotestresult");
    }

    @RequestMapping("/testexecute")
    @ResponseBody
    public BaseResponse testexecute(String env) {
        AutoTestReq autoTestReq = new AutoTestReq();
        autoTestReq.setEnv(env);
        BaseResponse emailResponse = httpRestClient.defaultPost(HttpUriContants.GET_EMAIL_BY_ALARM_GROUP+"?groupName=" + AlarmGroupContants.GROUP_NAME_YUNWEI, null, BaseResponse.class);
        if(emailResponse.getData() != null){
            autoTestReq.setMailto((String)emailResponse.getData());
        }
        BaseResponse baseResponse = httpRestClient.post("http://qmc.yohops.com:9999/autoTask/executeApiAutoTask", autoTestReq, BaseResponse.class);
        return baseResponse;
    }

    @RequestMapping("/testget")
    public BaseResponse testget(String id) {
        AutoTestReq autoTestReq = new AutoTestReq();
        autoTestReq.setId(id);
        BaseResponse baseResponse = httpRestClient.post("http://qmc.yohops.com:9999/autoTask/getAutoTestExecuteResult", autoTestReq, BaseResponse.class);
        return baseResponse;
    }
}