package com.sunda.spmsweb.oacontroller;

import com.alibaba.fastjson.JSONObject;
import com.sun.mail.imap.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.sunda.spmscommon.ResponseResult;
import com.sunda.spmscommon.entity.ZSapOrgClient;
import com.sunda.spmscommon.feign.IFeignServiceCommon;
import com.sunda.spmscommon.mapper.ZSapOrgClientMapper;
import com.sunda.spmscommon.service.ISysLogMqService;
import com.sunda.spmsorder.entity.OrderKeyValueConfig;
import com.sunda.spmsorder.service.IMaterialApplicationService;
import com.sunda.spmsorder.service.IOrderKeyValueConfigService;
import com.sunda.spmsorder.service.IOrderWerksService;
import com.sunda.spmsoversea.service.IOverseaInvCheckActionService;
import com.sunda.spmsoversea.service.IOverseaWhsDumpService;
import com.sunda.spmsuser.entity.SpmsUser;
import com.sunda.spmsuser.service.ISpmsUserService;
import com.sunda.spmsweb.aspect.Login;
import com.sunda.spmsweb.aspect.Operation;
import com.sunda.spmsweb.ibmmqservice.SendMessageInterface;
import com.sunda.spmsweb.oaservice.OaService;
import com.sunda.spmsweb.util.JWTUtil;
import com.sunda.spmsweb.util.MD5Utils;
import feign.FeignException;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.shiro.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeUtility;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;

import static com.sunda.spmscommon.Constans.*;

/**
 * @program: spms
 * @description: OA Auth Controller
 * @author: Wayne Wu
 * @create: 2020-10-27 15:49
 **/
@Slf4j
@RestController
@RequestMapping("/oa")
@Api(tags = "OA相关接口", description = "OA相关接口")
public class oacontroller {

    @Autowired
    ISpmsUserService iSpmsUserService;

    @Autowired
    IOrderWerksService iOrderWerksService;

    @Autowired
    SendMessageInterface sendMessageInterface;

    @Autowired
    IMaterialApplicationService iMaterialApplicationService;

    @Autowired
    IOverseaInvCheckActionService iOverseaInvCheckActionService;

    @Autowired
    IOverseaWhsDumpService iOverseaWhsDumpService;

    @Autowired
    IFeignServiceCommon iFeignServiceCommon;
    
    @Autowired
    ZSapOrgClientMapper zSapOrgClientMapper;

    @Autowired
    ISysLogMqService iSysLogMqService;
    @Autowired
    IOrderKeyValueConfigService iOrderKeyValueConfigService;

    @Value("${oa.new.url}")
    String oaUrl;

    @Value("${oa.token}")
    String token;

    /** @Login 监控登录用户记录日志; 用户登录，成功则返回用户相关信息——用户个人信息、角色、权限、工厂、车间 配置信息 */
    @Login(operateType = "登录")
    @RequestMapping(value = "/login")
    @ApiOperation(value = "OA用户登陆获取 token 信息",notes = "token = " +
            "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTc3NTY2NjJ9.Z5DGPyA10VBF1WC77GprP-Llv-O8ySHhmRUGV-h7tU0\n\n" +
            "OA系统请求路径参考：\nhttp://192.168.106.90/external/#/external/oaview?token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTc5MzQ0ODEsInVzZXJJZCI6Ijk5OTk0NyJ9.DcXsnU41dfKKbXWx15ZreieNy6hFhqyaR2ezsUuP_Bc&spmsId=GF03-2021-003"
            , httpMethod = "POST")
    public ResponseResult login(String userId, String accesskey) {
        try {
            //校验令牌，正确的话发放新的令牌；否则返回错误信息；
            if (accesskey.equals(token)){
                SpmsUser user = iSpmsUserService.getByUserId(userId);
                if (user == null){
                    List<OrderKeyValueConfig> orderKeyValueConfigs = iOrderKeyValueConfigService.getByFieldKey("oaConfig");
                    boolean newOa = false;
                    if(orderKeyValueConfigs!=null && orderKeyValueConfigs.size()>0){
                        String oaConfig = orderKeyValueConfigs.get(0).getKeyCode();
                        if("0".equals(oaConfig)){//0:启用新OA接口
                            newOa = true;
                        }
                    }
                    OaService oaService = new OaService();
                    Map<String, Object> map = new HashMap<>();
                    if(newOa){
                        map = oaService.getUserInfoByOaV2(userId,oaUrl);
                    }else{
                        map = oaService.getUserInfo(userId);
                    }
                    if (map == null){
                        return ResponseResult.loginError("Access denied.");
                    }
                    String MDPassword = MD5Utils.encrypt(userId, "12345678");
                    iSpmsUserService.oaCreateSpmsUser(map, MDPassword);
                }
                return ResponseResult.success().add("token", JWTUtil.createOaToken(userId));
            }
            return ResponseResult.loginError("Access denied.");
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("e===" + e);
            return ResponseResult.error();
        }
    }


    /** @Login 监控登录用户记录日志; 用户登录，成功则返回用户相关信息——用户个人信息、角色、权限、工厂、车间 配置信息 */
    @Login(operateType = "登录")
    @RequestMapping(value = "/esblogin")
    @ApiOperation(value = "ESB用户登陆获取 token 信息",notes = "token = " +
            "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTc3NTY2NjJ9.Z5DGPyA10VBF1WC77GprP-Llv-O8ySHhmRUGV-h7tU0\n\n" +
            "ESB系统请求路径参考：\nhttp://192.168.106.90/external/#/external/oaview?token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTc5MzQ0ODEsInVzZXJJZCI6Ijk5OTk0NyJ9.DcXsnU41dfKKbXWx15ZreieNy6hFhqyaR2ezsUuP_Bc&spmsId=GF03-2021-003"
            , httpMethod = "POST")
    public ResponseResult esblogin(@RequestBody JSONObject doc) {
        ResponseResult responseResult = new ResponseResult();
        try {
            String userId = doc.get("userId")==null?"":doc.get("userId").toString();
            String accesskey = doc.get("accesskey")==null?"":doc.get("accesskey").toString();
            //校验令牌，正确的话发放新的令牌；否则返回错误信息；
            if (accesskey.equals(token)){
                SpmsUser user = iSpmsUserService.getByUserId(userId);
                if (user == null){
                    List<OrderKeyValueConfig> orderKeyValueConfigs = iOrderKeyValueConfigService.getByFieldKey("oaConfig");
                    boolean newOa = false;
                    if(orderKeyValueConfigs!=null && orderKeyValueConfigs.size()>0){
                        String oaConfig = orderKeyValueConfigs.get(0).getKeyCode();
                        if("0".equals(oaConfig)){//0:启用新OA接口
                            newOa = true;
                        }
                    }
                    OaService oaService = new OaService();
                    Map<String, Object> map = new HashMap<>();
                    if(newOa){
                        map = oaService.getUserInfoByOaV2(userId,oaUrl);
                    }else{
                        map = oaService.getUserInfo(userId);
                    }
                    if (map == null){
                        responseResult.setCode(200);
                        responseResult.setMsg("Access denied.");
                        return responseResult;
                    }
                    String MDPassword = MD5Utils.encrypt(userId, "12345678");
                    iSpmsUserService.oaCreateSpmsUser(map, MDPassword);
                }
                responseResult.setCode(300);
                responseResult.setMsg("请求成功");
                responseResult.add("token", JWTUtil.createOaToken(userId));
                return responseResult;
            }
            responseResult.setCode(200);
            responseResult.setMsg("Access denied.");
            return responseResult;
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("e===" + e);
            responseResult.setCode(200);
            responseResult.setMsg("请求失败");
            return ResponseResult.error();
        }
    }

    @Operation(logContent = "OA审批结果回写SPMS", operateType = "修改")
    @RequestMapping("/updateOrderWerksStatus")
    @ApiOperation(value = "工厂请购单OA审批结果回写SPMS", notes = "OA 审批通过工厂请购单，oaBianhao：工厂请购单在 OA 编号；oaStatus：S - OA审批通通过；其他状态暂被忽略；\n" +
            "示例参数：oaBianhao = 938287, oaStatus = S \n" +
            "审批通过更新工厂请购单 spms 状态为：OA审批通过；更新完成后台自动将数据以 MQ 发送给 SRM。", httpMethod = "POST")
    @Transactional(rollbackFor = Exception.class)
    public ResponseResult updateOrderWerksStatus(String oaBianhao, String oaStatus,String sourceType) {

//        String protocol = "imap";//使用imap协议
//        boolean isSSL = true;//使用SSL加密
//        /*
//         *Properties是一个属性对象，用来创建Session对象
//         */
//        try{
//            Properties props = new Properties();
//            props.put("mail.imap.auth.plain.disable",true);
//            props.put("mail.imap.ssl.enable",true);
//            props.put("mail.imap.auth", true); //这样才能通过验证
//            props.put("mail.imap.host", "imap.163.com");
//            props.put("mail.imap.port", "993");
//
//            Session session = Session.getInstance(props);
//
//            HashMap IAM = new HashMap();
//            //带上IMAP ID信息，由key和value组成，例如name，version，vendor，support-email等。
//            // 这个value的值随便写就行
//            IAM.put("name","myname");
//            IAM.put("version","1.0.0");
//            IAM.put("vendor","myclient");
//            IAM.put("support-email","srmservice@51qqt.com");
//
//            /*
//             * Store类实现特定邮件协议上的读、写、监视、查找等操作。
//             * 通过Store类可以访问Folder类。
//             * Folder类用于分级组织邮件，并提供照Message格式访问email的能力。
//             */
//            IMAPStore store = null;
//            Folder folder = null;
//            try {
//                store = (IMAPStore)session.getStore(protocol);
//                store.connect("18302060852@163.com", "LHIDLVXYOEIDFIUZ");
//                store.id(IAM);
//                folder = store.getFolder("INBOX");// 获得用户的邮件帐户
//                folder.open(Folder.READ_WRITE); // 设置对邮件帐户的访问权限
//                Message[] messages = folder.getMessages();
//                for(int i=0;i<messages.length;i++) {
//                    MimeMessage msg = (MimeMessage) messages[i];
//                    String Msubject = getSubject(msg);
//                    String FromUser = getFrom(msg);
//                    String receiveAddress = getReceiveAddress(msg, null);
//                    String sentDate = getSentDate(msg, null);
//                    boolean seen = isSeen(msg);
//                    StringBuffer content = new StringBuffer(30);
//                    getMailTextContent(msg, content);
//                    System.out.println(content);
//                }
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//        }catch (Exception e){
//            e.printStackTrace();
//        }


        String userId = JWTUtil.getUserId(SecurityUtils.getSubject().getPrincipal().toString());
        try {
            log.info("工厂请购单OA审批结果回写SPMS===oaBianhao："+oaBianhao+"===oaStatus："+oaStatus+"===sourceType："+sourceType);
            /** OA 更新工厂请购单状态，如果 S 审批通过则工厂请购单更新成功后立马发送消息给 SRM */
            int result = iOrderWerksService.updateOrderWerksStatus(userId, oaBianhao, oaStatus);
            if (result == 1){
                /** OA 审批通过，SPMS 状态更新成功。则发送消息给 SRM 系统；
                 * 20211101 由MQ方式修改为REST请求方式
                 * */
                JSONObject restDataToSrm = restDataToSrm(oaBianhao);
                log.info("=======restDataToSrm=======" + restDataToSrm);
                JSONObject message = JSONObject.parseObject(iFeignServiceCommon.sendRestToSapCommon(restDataToSrm));
                log.info("=======message=======" + message);
                JSONObject RETURN_DATA = message.getJSONObject("RESPONSE").getJSONObject("RETURN_DATA");
                if (RETURN_DATA.containsKey("status") && "S".equals(RETURN_DATA.getString("status"))){
                    /** 状态 5 表示提交 SRM 成功；状态 8 表示提交 SRM 失败； **/
                    String status = String.valueOf(5);
                    iOrderWerksService.updateOrderWerksStatusByOaBianhao(userId, oaBianhao, status);
                    iSysLogMqService.addSysLogMq("3", "spms_srm_purchase_info", REQUEST_SEND_SRM,
                            "spms_srm_purchase_info", restDataToSrm.toJSONString(), message.toJSONString(), oaBianhao);
                    return ResponseResult.success("OA审批通过，提交SRM成功");
                } else {
                    String status = String.valueOf(8);
                    iOrderWerksService.updateOrderWerksStatusByOaBianhao(userId, oaBianhao, status);
                    iSysLogMqService.addSysLogMq("3", "spms_srm_purchase_info", REQUEST_SEND_SRM_ERROR,
                            "spms_srm_purchase_info", restDataToSrm.toJSONString(), message.toJSONString(), oaBianhao);
                    return ResponseResult.error("OA审批通过，提交SRM出错")
                            .add("message", message.toJSONString());
                }

                /** 原MQ请求方式；状态 5 表示提交 SRM 成功；状态 8 表示提交 SRM 失败；
                int resp = sendMessageInterface.spms_srm_purchase_info2(oaBianhao);
                if (resp == 1){
                    String status = String.valueOf(5);
                    iOrderWerksService.updateOrderWerksStatusByOaBianhao(userId, oaBianhao, status);
                    return ResponseResult.success("OA审批通过，提交SRM成功");
                }
                if (resp == 0){
                    String status = String.valueOf(8);
                    iOrderWerksService.updateOrderWerksStatusByOaBianhao(userId, oaBianhao, status);
                    return ResponseResult.error("OA审批通过，提交SRM出错");
                }
                 **/
            }else if (result == -1){
                /** OA 审批不通过，SPMS 状态更新成功。不发送消息给 SRM 系统；*/
                return ResponseResult.success();
            }else if (result == -2){
                /** 对应单据已审批通通过，防止重复提交 */
                return ResponseResult.error("单据已审批通通过请勿重复提交");
            } else if (result == -3){
                return ResponseResult.success("单据审批通过不提交SRM");
            }
            /** result = 0 更新失败 */
            return ResponseResult.error("SPMS状态更新失败");
        } catch (FeignException feignException){
            feignException.printStackTrace();
            //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return ResponseResult.error("请求SRM失败 FeignException").add("error", feignException.getMessage());
        }catch (Exception e) {
            e.printStackTrace();
            //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return ResponseResult.error("请求异常请重试:" + e.getMessage());
        }
    }



    /**
     * 获得邮件主题
     * @param msg 邮件内容
     * @return 解码后的邮件主题
     */
    public static String getSubject(MimeMessage msg) throws UnsupportedEncodingException, MessagingException {
        return MimeUtility.decodeText(msg.getSubject());
    }

    /**
     * 获得邮件发件人
     * @param msg 邮件内容
     * @return 姓名 <Email地址>
     * @throws MessagingException
     * @throws UnsupportedEncodingException
     */
    public static String getFrom(MimeMessage msg) throws MessagingException, UnsupportedEncodingException {
        String from = "";
        Address[] froms = msg.getFrom();
        if (froms.length < 1)
            throw new MessagingException("没有发件人!");

        InternetAddress address = (InternetAddress) froms[0];
        String person = address.getPersonal();
        if (person != null) {
            person = MimeUtility.decodeText(person) + " ";
        } else {
            person = "";
        }
        from = person + "<" + address.getAddress() + ">";

        return from;
    }

    /**
     * 根据收件人类型，获取邮件收件人、抄送和密送地址。如果收件人类型为空，则获得所有的收件人
     * <p>Message.RecipientType.TO  收件人</p>
     * <p>Message.RecipientType.CC  抄送</p>
     * <p>Message.RecipientType.BCC 密送</p>
     * @param msg 邮件内容
     * @param type 收件人类型
     * @return 收件人1 <邮件地址1>, 收件人2 <邮件地址2>, ...
     * @throws MessagingException
     */
    public static String getReceiveAddress(MimeMessage msg, Message.RecipientType type) throws MessagingException {
        StringBuffer receiveAddress = new StringBuffer();
        Address[] addresss = null;
        if (type == null) {
            addresss = msg.getAllRecipients();
        } else {
            addresss = msg.getRecipients(type);
        }

        if (addresss == null || addresss.length < 1)
            throw new MessagingException("没有收件人!");
        for (Address address : addresss) {
            InternetAddress internetAddress = (InternetAddress)address;
            receiveAddress.append(internetAddress.toUnicodeString()).append(",");
        }

        receiveAddress.deleteCharAt(receiveAddress.length()-1);	//删除最后一个逗号

        return receiveAddress.toString();
    }

    /**
     * 获得邮件发送时间
     * @param msg 邮件内容
     * @return yyyy年mm月dd日 星期X HH:mm
     * @throws MessagingException
     */
    public static String getSentDate(MimeMessage msg, String pattern) throws MessagingException {
        Date receivedDate = msg.getSentDate();
        if (receivedDate == null)
            return "";

        if (pattern == null || "".equals(pattern))
            pattern = "yyyy年MM月dd日 E HH:mm ";

        return new SimpleDateFormat(pattern).format(receivedDate);
    }

    /**
     * 判断邮件是否已读
     * @param msg 邮件内容
     * @return 如果邮件已读返回true,否则返回false
     * @throws MessagingException
     */
    public static boolean isSeen(MimeMessage msg) throws MessagingException {
        return msg.getFlags().contains(Flags.Flag.SEEN);
    }


    /**
     * 获得邮件文本内容
     * @param part 邮件体
     * @param content 存储邮件文本内容的字符串
     * @throws MessagingException
     * @throws IOException
     */
    public static void getMailTextContent(Part part, StringBuffer content) throws MessagingException, IOException {
        //如果是文本类型的附件，通过getContent方法可以取到文本内容，但这不是我们需要的结果，所以在这里要做判断
        boolean isContainTextAttach = part.getContentType().indexOf("name") > 0;
        if (part.isMimeType("text/*") && !isContainTextAttach) {
            content.append(part.getContent().toString());
        } else if (part.isMimeType("message/rfc822")) {
            getMailTextContent((Part)part.getContent(),content);
        } else if (part.isMimeType("multipart/*")) {
            Multipart multipart = (Multipart) part.getContent();
            int partCount = multipart.getCount();
            for (int i = 0; i < partCount; i++) {
                BodyPart bodyPart = multipart.getBodyPart(i);
                getMailTextContent(bodyPart,content);
            }
        }
    }



    /**
     * 读取输入流中的数据保存至指定目录
     * @param is 输入流
     * @param fileName 文件名
     * @param destDir 文件存储目录
     * @throws FileNotFoundException
     * @throws IOException
     */
    private static void saveFile(InputStream is, String destDir, String fileName)
            throws FileNotFoundException, IOException {
        BufferedInputStream bis = new BufferedInputStream(is);
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(new File(destDir + fileName)));
        int len = -1;
        while ((len = bis.read()) != -1) {
            bos.write(len);
            bos.flush();
        }
        bos.close();
        bis.close();
    }

    /**
     * 文本解码
     * @param encodeText 解码MimeUtility.encodeText(String text)方法编码后的文本
     * @return 解码后的文本
     * @throws UnsupportedEncodingException
     */
    public static String decodeText(String encodeText) throws UnsupportedEncodingException {
        if (encodeText == null || "".equals(encodeText)) {
            return "";
        } else {
            return MimeUtility.decodeText(encodeText);
        }
    }


    @SuppressWarnings("unchecked")
	JSONObject restDataToSrm(String oaBianhao) throws Exception{
        JSONObject doc = new JSONObject();
        Map<String, Object> DATA = iOrderWerksService.orderWerksToSrm2(oaBianhao);
        JSONObject REQUEST = new JSONObject();
        JSONObject ESB_ATTRS = new JSONObject();
        JSONObject REQUEST_DATA = new JSONObject();
        ESB_ATTRS.put("Application_ID", "00020000000004");
        ESB_ATTRS.put("Transaction_ID", UUID.randomUUID().toString());
        ESB_ATTRS.put("App_ID", "SPMS");
        // 根据工厂查询clinet值，Target_ID传不同值以区分乐舒适系统
 		Map<String, Object> headMap = (Map<String, Object>) DATA.get("Head");
 		List<ZSapOrgClient> selectList = zSapOrgClientMapper.selectList(new QueryWrapper<ZSapOrgClient>().eq("WERKS", headMap.get("werks").toString()));
 		if (CollectionUtils.isNotEmpty(selectList)) {
 			String zmandt = selectList.get(0).getZmandt();
 			if ("510".equals(zmandt) || "810".equals(zmandt)) {
 				ESB_ATTRS.put("Target_ID", "SRM-"+zmandt);
 			} else {
 				ESB_ATTRS.put("Target_ID", "SRM-SAP");
 			}
 		} else {
 			throw new Exception("工厂：" + headMap.get("purchaseWerks") + "未找到对应的SAP Clinet");
 		}
        JSONObject SendData = new JSONObject();
        SendData.put("Head", DATA.get("Head"));
        SendData.put("Items", DATA.get("Items"));
        REQUEST_DATA.put("SendData", SendData);
//        REQUEST_DATA.put("Head", DATA.get("Head"));
//        REQUEST_DATA.put("Items", DATA.get("Items"));
        REQUEST_DATA.put("Operation", "SPMS_SRM_PURCHASE_INFO_NEW");
        REQUEST_DATA.put("Type", "SPMS_SRM_PURCHASE_INFO_NEW");

        REQUEST.put("ESB_ATTRS", ESB_ATTRS);
        REQUEST.put("REQUEST_DATA", REQUEST_DATA);

        doc.put("REQUEST", REQUEST);
        return doc;
    }

    @Operation(logContent = "物料申请OA审批结果回写SPMS", operateType = "修改")
    @RequestMapping("/updateMaterialApplicationStatus")
    @ApiOperation(value = "物料申请单OA审批结果回写SPMS", notes = "OA 审批通过物料申请单，oaBianhao：物料申请单在 OA 编号；oaStatus：S - OA审批通通过；其他状态暂被忽略；\n" +
            "示例参数：oaBianhao = 938287, oaStatus = S \n" +
            "审批通过更新物料申请单 spms 状态为：OA审批通过；", httpMethod = "POST")
    @Transactional(rollbackFor = Exception.class)
    public ResponseResult updateMaterialApplicationStatus(String oaBianhao, String oaStatus,String sourceType) {
        String userId = JWTUtil.getUserId(SecurityUtils.getSubject().getPrincipal().toString());
        try {
            log.info("物料申请单OA审批结果回写SPMS===oaBianhao："+oaBianhao+"===oaStatus："+oaStatus+"===sourceType："+sourceType);
            /** OA 更新物料申请单状态，如果 S 审批通过则物料申请单更新成功 */
            int result = iMaterialApplicationService.updateMaterialApplicationStatus(userId, oaBianhao, oaStatus);
            if (result == 1){
                return ResponseResult.success("OA审批通过");
            }else if (result == -1){
                /** OA 审批不通过，SPMS 状态更新成功*/
                return ResponseResult.success();
            }else if (result == -2){
                /** 对应单据已审批通通过，防止重复提交 */
                return ResponseResult.error("单据已审批通通过请勿重复提交");
            }
            /** result = 0 更新失败 */
            return ResponseResult.error("SPMS状态更新失败");
        } catch (Exception e) {
            e.printStackTrace();
            //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return ResponseResult.error("请求异常请重试:" + e.getMessage());
        }
    }

    @Operation(logContent = "盘亏盘盈申请OA审批结果回写SPMS", operateType = "修改")
    @RequestMapping("/updateInvChkAcStatus")
    @ApiOperation(value = "盘亏盘盈申请OA审批结果回写SPMS", notes = "盘亏盘盈申请OA审批结果回写SPMS，oaBianhao：物料申请单在 OA 编号；oaStatus：S - OA审批通通过；其他状态暂被忽略；\n" +
            "示例参数：oaBianhao = 938287, oaStatus = S \n" +
            "审批通过更新盘点盘亏盘盈单 spms 状态为：OA审批通过(5) OA审批失败(4)；", httpMethod = "POST")
    public ResponseResult updateInvChkAcStatus(String oaBianhao, String oaStatus,String sourceType) {
        String userId = JWTUtil.getUserId(SecurityUtils.getSubject().getPrincipal().toString());
        try {
            log.info("盘亏盘盈申请OA审批结果回写SPMS===oaBianhao："+oaBianhao+"===oaStatus："+oaStatus+"===sourceType："+sourceType);
            /** OA 更新盘盈盘亏单状态，如果 S 审批通过则盘盈盘亏单更新成功 */
            return iOverseaInvCheckActionService.updateOverseaInvChkAcByOa(userId, oaBianhao, oaStatus);
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("请求异常请重试:" + e.getMessage());
        }
    }

    @Operation(logContent = "转储申请OA审批结果回写SPMS", operateType = "修改")
    @RequestMapping("/updateDumpStatus")
    @ApiOperation(value = "海外转储申请OA审批结果回写SPMS", notes = "海外转储申请OA审批结果回写SPMS，oaBianhao：物料申请单在 OA 编号；oaStatus：S - OA审批通通过；其他状态暂被忽略；\n" +
            "示例参数：oaBianhao = 1239464, oaStatus = S \n" +
            "审批通过更新转储任务状态 spms 状态为：OA驳回(4) OA审批通过(4)；", httpMethod = "POST")
    public ResponseResult updateDumpStatus(String oaBianhao, String oaStatus,String sourceType) {
        log.info("海外转储申请OA审批结果回写SPMS===oaBianhao："+oaBianhao+"===oaStatus："+oaStatus+"===sourceType："+sourceType);
        String userId = JWTUtil.getUserId(SecurityUtils.getSubject().getPrincipal().toString());
        try {
            /** OA 审批海外转储申请，如果 oaStatus = S 则审批通过，oaStatus = E 审批驳回，更新对应转储任务状态 */
            return iOverseaWhsDumpService.oaApproveWhsDump(oaBianhao, oaStatus, userId);
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("请求异常请重试:" + e.getMessage());
        }
    }

    /**
     * http://192.168.106.90/external/#/external/oaview?token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTc5MzQ0ODEsInVzZXJJZCI6Ijk5OTk0NyJ9.DcXsnU41dfKKbXWx15ZreieNy6hFhqyaR2ezsUuP_Bc&spmsId=GF03-2021-003
     */
    @GetMapping("/getOaApprovePage")
    @ApiOperation(value = "OA审批查看页面地址", notes ="工厂请购单OA审批页面\n\n" +
            "http://192.168.106.90/external/#/external/oaview?token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTc5MzQ0ODEsInVzZXJJZCI6Ijk5OTk0NyJ9.DcXsnU41dfKKbXWx15ZreieNy6hFhqyaR2ezsUuP_Bc&spmsId=GF03-2021-003")
    public void updateOrderWerksStatus() {

    }

    @RequestMapping("/updateSpmsUserInfo")
    @ApiOperation(value = "实时同步用户OA信息到SPMS",notes = "实时同步用户OA信息到SPMS",
            httpMethod = "GET")
    public ResponseResult updateSpmsUserInfo(String userId) {
        if (StringUtils.isEmpty(userId)){
            return ResponseResult.error("请求参数不能为空");
        }
        try{
            List<OrderKeyValueConfig> orderKeyValueConfigs = iOrderKeyValueConfigService.getByFieldKey("oaConfig");
            boolean newOa = false;
            if(orderKeyValueConfigs!=null && orderKeyValueConfigs.size()>0){
                String oaConfig = orderKeyValueConfigs.get(0).getKeyCode();
                if("0".equals(oaConfig)){//0:启用新OA接口
                    newOa = true;
                }
            }
            OaService oaService = new OaService();
            Map<String, Object> map = new HashMap<>();
            if(newOa){
                map = oaService.getUserInfoByOaV2(userId,oaUrl);
            }else{
                map = oaService.getUserInfo(userId);
            }
            if (map == null || map.size() == 0){
                return ResponseResult.error("OA返回信息错误");
            }
            return iSpmsUserService.updateSpmsUserInfo(map);
        } catch (Exception e){
            e.printStackTrace();
            return ResponseResult.error("请求异常请重试:" + e);
        }
    }

//    @Autowired
//    IUUserRoleService iuUserRoleService;
//
//    @RequiresRoles(value = {"oa"})
//    @RequestMapping("/getRequestDtl")
//    @ApiOperation(value = "获取请购单详情",notes = "username", httpMethod = "GET")
//    public ResponseResult getRequestDtl(String userid, String applicantId) {
//        Set<String> roleSet = new HashSet<String>();
//        for (URole r : iuUserRoleService.getRoleById(userid)) {
//            roleSet.add(r.getName());
//        }
//        System.out.println(roleSet);
//        if (roleSet.contains("oa"))
//            return ResponseResult.success().add("applicantId", applicantId + " 详情信息，SKU + Qty ......");
//        else
//            return ResponseResult.error("Access denied.");
//    }

//    @RequestMapping("/getUserInfo")
//    @ApiOperation(value = "获取用户详细信息",notes = "获取指定工号的用户详细信息，示例 userId = 999947",
//            httpMethod = "POST")
//    public ResponseResult getOrderScenario(String userId) {
//        OaService oaService = new OaService();
//        try{
//            return oaService.getUserInfo(userId);
//        } catch (Exception e){
//            return ResponseResult.error("请求异常请重试:" + e);
//        }
//    }

}