package com.phxl.modules.goods.web.spd;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
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 org.springframework.web.multipart.MultipartFile;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.phxl.common.constants.PlatformConstant;
import com.phxl.common.response.PlatFormResponse;
import com.phxl.common.response.PlatFormResponseConstant;
import com.phxl.common.util.HTTPClient;
import com.phxl.common.utils.IdUtil;
import com.phxl.modules.goods.entity.billback.BillBackWithDetail;
import com.phxl.modules.goods.entity.billsettlement.BillSettlementWithDetail;
import com.phxl.modules.goods.entity.ctcareprov.CTCareProv;
import com.phxl.modules.goods.entity.ctdept.HisCtDept;
import com.phxl.modules.goods.entity.hisCtMedicineMaterial.HisCtMedicineMaterial;
import com.phxl.modules.goods.entity.invoiceback.SuInvoiceBackWithDetail;
import com.phxl.modules.goods.entity.medinstore.MedInStoreWithDetail;
import com.phxl.modules.goods.entity.medplan.MedPlanWithDetail;
import com.phxl.modules.goods.entity.medstock.MedStockList;
import com.phxl.modules.goods.entity.spills.HisSpillsList;
import com.phxl.modules.goods.entity.suoutstore.SuOutStoreWithDetail;
import com.phxl.modules.goods.entity.supplierstock.SupplierStockList;
import com.phxl.modules.goods.entity.supplygoods.MedSupplyGoods;
import com.phxl.modules.goods.service.billback.BillBackService;
import com.phxl.modules.goods.service.billsettlement.BillSettlementService;
import com.phxl.modules.goods.service.ctcareprov.CTCareProvService;
import com.phxl.modules.goods.service.ctdept.HisCtDeptService;
import com.phxl.modules.goods.service.hisCtMedicineMaterial.HisCtMedicineMaterialService;
import com.phxl.modules.goods.service.interfaceLog.InterfaceLogService;
import com.phxl.modules.goods.service.invoiceback.SuInvoiceBackService;
import com.phxl.modules.goods.service.medinstore.MedInStoreService;
import com.phxl.modules.goods.service.medplan.MedPlanService;
import com.phxl.modules.goods.service.medstock.MedStockService;
import com.phxl.modules.goods.service.spills.HisSpillsService;
import com.phxl.modules.goods.service.suoutstore.SuOutStoreService;
import com.phxl.modules.goods.service.supplierstock.SupplierStockService;
import com.phxl.modules.goods.service.supplygoods.MedSupplyGoodsService;

@Controller
@RequestMapping(value = "/Api")
public class SpdControlller {

    /**
     * 日志对象
     */
    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
	private HisCtMedicineMaterialService ctMedicineMaterialService;
    
    @Autowired
    private InterfaceLogService interfaceLogService;
    
    @Autowired
    private HisCtDeptService hisCtDeptService;
    
    @Autowired
    private CTCareProvService cTCareProvService;
    
    @Autowired
    private MedSupplyGoodsService supplyGoodsService;
    
    @Autowired
    private MedStockService	stockService;
    
    @Autowired
    private  MedPlanService medPlanService;
    
    @Autowired
    private  MedInStoreService medInStoreService;
    
    @Autowired
    private BillBackService backService;
    
    @Autowired
    private BillSettlementService billSettlementService;
    
    @Autowired
    private SupplierStockService supplierStockService;
    
    @Autowired
    private SuOutStoreService suOutStoreService;
    
    @Autowired
    private HisSpillsService hisSpillsService;
    
    @Autowired
    private SuInvoiceBackService suInvoiceBackService;
    
    
    @RequestMapping(value="/setMFMedGoods")
    @ResponseBody
    public String setMFMedGoods(String id,HttpServletRequest request, @RequestBody String medgoodsList){
    	logger.debug("药品目录接口请求参数:{}",medgoodsList);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setMFMedGoods:(药品目录)", medgoodsList, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<HisCtMedicineMaterial> materials = new ArrayList<HisCtMedicineMaterial>();
		try {
			materials = JSONObject.parseArray(medgoodsList, HisCtMedicineMaterial.class);
			for (HisCtMedicineMaterial hisCtMedicineMaterial : materials) {
				ctMedicineMaterialService.saveMedicine(hisCtMedicineMaterial);
			}
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
			response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			result = JSON.toJSONString(response);
			//medgoodsList = ctMedicineMaterialService.createRequest();
			//供应商服务请求：
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url+"setMFMedGoods", medgoodsList);
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg(e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
    }
    
    @RequestMapping(value="/setHDept")
    @ResponseBody
    public String setHDept(String id,HttpServletRequest request, @RequestBody String params){
    	logger.debug("医院科室资料接口请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setHDept:(医院科室)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<HisCtDept> depts = new ArrayList<HisCtDept>();
		try {
			depts = JSONObject.parseArray(params, HisCtDept.class);
			int end = hisCtDeptService.batchSaveOrUpdate(depts);
			if(end==1){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			//供应商服务请求：
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url+"setHDept", params);
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg(e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
    }
    
    /**
	 * 医院人员资料接口
	 * @param request
	 * @param params
	 * @return
	 */
	@RequestMapping("/setMedStaff")
	@ResponseBody
	public String setMedStaff(HttpServletRequest request, @RequestBody String params){
		logger.debug("医院人员资料接口请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setMedStaff:(医院人员资料)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<CTCareProv> careProvs = new ArrayList<CTCareProv>();
		boolean end = false;
		try {
			careProvs = JSONObject.parseArray(params, CTCareProv.class);
			end = cTCareProvService.batchSaveOrUpdate(careProvs);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			//供应商服务请求：
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url+"setMedStaff", params);
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg(e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
	
	
	/**
	 * 医院采购目录接口
	 * @param request
	 * @param params
	 * @return
	 */
	@RequestMapping("/setMFSupplyGoods")
	@ResponseBody
	public String setMFSupplyGoods(HttpServletRequest request, @RequestBody String params){
		logger.debug("医院采购目录接口请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setMFSupplyGoods:(医院采购目录)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<MedSupplyGoods> supplyGoods  = new ArrayList<MedSupplyGoods>();
		boolean end = false;
		try {
			supplyGoods = JSONObject.parseArray(params, MedSupplyGoods.class);
			end = supplyGoodsService.batchSave(supplyGoods);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			//供应商服务请求：
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url+"setMedContent", params);
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg(e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
	
	
	/**
	 * 医院库存接口
	 * @param request
	 * @param params
	 * @return
	 */
	@ResponseBody
	@RequestMapping(value="/setMedStock",method = RequestMethod.POST)
	public String setMedStock(HttpServletRequest request, @RequestBody String params){
		logger.debug("HLI同步医院库存数据请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setMedStock:(医院库存)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<MedStockList> stocks  = new ArrayList<MedStockList>();
		boolean end = false;
		try {
			stocks = JSONObject.parseArray(params, MedStockList.class);
			end = stockService.batchSave(stocks);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			//供应商服务请求：
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url+"setMedStock", params);
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg(e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
    
	
	/**
	 * 医院补货计划接口
	 * @param request
	 * @param params
	 * @return
	 */
	@RequestMapping("/setMedPlan")
	@ResponseBody
	public String setMedPlan(HttpServletRequest request, @RequestBody String params){
		logger.debug("补货计划接口请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setMedPlan:(补货计划)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<MedPlanWithDetail> medPlans = new ArrayList<MedPlanWithDetail>();
		boolean end = false;
		try {
			//改成批量的操作
			medPlans = JSONObject.parseArray(params, MedPlanWithDetail.class);
			end = medPlanService.batchSave(medPlans);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			//供应商服务请求：
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url+"setMedPlan", params);
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg(e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
    
	
	/**
	 * 医院退货接口
	 * @param request
	 * @param params
	 * @return
	 */
	@RequestMapping("/setTRMedRPI")
	@ResponseBody
	public String setTRMedRPI(HttpServletRequest request, @RequestBody String params){
		logger.debug("医院退货计划接口请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setTRMedRPI:(医院退货计划)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<BillBackWithDetail> billBacks = new ArrayList<BillBackWithDetail>();
		boolean end = false;
		try {
			billBacks = JSONObject.parseArray(params, BillBackWithDetail.class);
			end = backService.batchSave(billBacks);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			//供应商服务请求：
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url+"setTrmedRPI", params);
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg(e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
	
	/**
	 * 结算单接口
	 * @param request
	 * @param params
	 * @return
	 */
	@RequestMapping("/setTRSettle")
	@ResponseBody
	public String setTRSettle(HttpServletRequest request, @RequestBody String params){
		logger.debug("同步医院结算单请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setTRSettle:(医院同步结算单)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<BillSettlementWithDetail> settlementWithDetails = new ArrayList<BillSettlementWithDetail>();
		boolean end = false;
		try {
			settlementWithDetails = JSONObject.parseArray(params, BillSettlementWithDetail.class);
			end = billSettlementService.batchSave(settlementWithDetails);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			//供应商服务请求：
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url + "setTrsettle", params);
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg(e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
	
	
	/**
	 * 供应商库存接口
	 * @param request
	 * @param params
	 * @return
	 */
	@RequestMapping("/setStock")
	@ResponseBody
	public String setStock(HttpServletRequest request, @RequestBody String params){
		logger.debug("供应商同步库存数据请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setStock:(供应商库存)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<SupplierStockList> supplierStocks  = new ArrayList<SupplierStockList>();
		boolean end = false;
		try {
			supplierStocks = JSONObject.parseArray(params, SupplierStockList.class);
			end = supplierStockService.batchSave(supplierStocks);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			try
			{
				//SPD服务请求：			
				result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_SPD_Url+"setStock", params);
				response = JSONObject.parseObject(result,PlatFormResponse.class);
				response.setMsg("SPD:"+response.getMsg());
			}
			catch(Exception ex){
				logger.error("SPD:"+ex.getMessage());
				exception = "SPD:"+ex.getMessage();
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg("SPD:"+ex.getMessage());
				result = JSON.toJSONString(response);
			}
		
		} catch (Exception e) {
			logger.error("前置机:"+e.getMessage());
			exception = "前置机:"+e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg("前置机："+e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
	
	
	/**
	 * 供应商出库单接口
	 * @param request
	 * @param params
	 * @return
	 */
	@RequestMapping("/setTrmedwv")
	@ResponseBody
	public String setTrmedwv(HttpServletRequest request, @RequestBody String params){
		logger.debug("同步供应商出库单请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setTrmedwv:(供应商出库单)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<SuOutStoreWithDetail> suOutStores = new ArrayList<SuOutStoreWithDetail>();
		boolean end = false;
		try {
			suOutStores = JSONObject.parseArray(params, SuOutStoreWithDetail.class);
			end = suOutStoreService.batchSave(suOutStores);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			try
			{
				//SPD服务请求：			
				result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_SPD_Url+"setTrmedwv", params);
				response = JSONObject.parseObject(result,PlatFormResponse.class);
				response.setMsg("SPD:"+response.getMsg());
			}
			catch(Exception ex){
				logger.error("SPD:"+ex.getMessage());
				exception = "SPD:"+ex.getMessage();
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg("SPD:"+ex.getMessage());
				result = JSON.toJSONString(response);
			}
			
		} catch (Exception e) {
			logger.error("前置机:"+e.getMessage());
			exception = "前置机:"+e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg("前置机："+e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
	
	/**
	 * 医院盘点损溢接口
	 * @param request
	 * @param params
	 * @return
	 */
	@RequestMapping(value="/setTrDiff")
    @ResponseBody
    public String setTrDiff(String id,HttpServletRequest request, @RequestBody String params){
    	logger.debug("医院盘点损溢接口请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setTrDiff:(盘点损溢)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<HisSpillsList> spills = new ArrayList<HisSpillsList>();
		boolean end = false;
		try {
			spills = JSONObject.parseArray(params, HisSpillsList.class);
			end = hisSpillsService.batchSave(spills);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			//供应商服务请求：
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url+"setTrDiff", params);
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg(e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
    }
	
	
	/**
	 * 供应商发票回传接口
	 * @param request
	 * @param params
	 * @return
	 */
	@RequestMapping("/setInvoice")
	@ResponseBody
	public String setInvoice(HttpServletRequest request, @RequestBody String params){
		logger.debug("供应商发票回传接口请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setInvoice:(供应商发票回传)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<SuInvoiceBackWithDetail> suInvoiceBackWithDetailList = new ArrayList<SuInvoiceBackWithDetail>();
		boolean end = false;
		try {
			suInvoiceBackWithDetailList = JSONObject.parseArray(params, SuInvoiceBackWithDetail.class);
			end = suInvoiceBackService.batchSaveOrUpdate(suInvoiceBackWithDetailList);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);		
			try
			{
				//SPD服务请求：			
				result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_SPD_Url+"setInvoice", params);
				response = JSONObject.parseObject(result,PlatFormResponse.class);
				response.setMsg("SPD:"+response.getMsg());
			}
			catch(Exception ex){
				logger.error("SPD:"+ex.getMessage());
				exception = "SPD:"+ex.getMessage();
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg("SPD:"+ex.getMessage());
				result = JSON.toJSONString(response);
			}
		
		} catch (Exception e) {
			logger.error("前置机:"+e.getMessage());
			exception = "前置机:"+e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg("前置机："+e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}

	/*
	 * 医院入库单回传接口
	 * @param request
	 * @param params
	 * @return
	 */
	@RequestMapping("/setMedInStore")
	@ResponseBody
	public String setMedInStore(HttpServletRequest request, @RequestBody String params){
		logger.debug("医院入库单回传接口请求参数:{}",params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("setMedInStore:(医院入库单回传)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		List<MedInStoreWithDetail> medInStores = new ArrayList<MedInStoreWithDetail>();
		boolean end = false;
		try {
			//改成批量的操作
			medInStores = JSONObject.parseArray(params, MedInStoreWithDetail.class);
			end = medInStoreService.batchSave(medInStores);
			if(end){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getSuccess_ResultContent);
			}else{
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg(PlatFormResponseConstant.ResponseBodyMsg.getFail_ResultContent);
			}
			result = JSON.toJSONString(response);
			//供应商服务请求：
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url+"setMedInStore", params);
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg(e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}

	/***
	 * 推送对账数据到平台
	 * @param params
	 * @return
	 */
	@RequestMapping("/pushBalance")
	@ResponseBody
	public String pushBalance(@RequestBody String params) {
		logger.debug("推送对账数据:{}", params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("pushBalance:(推送对账数据)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		try {
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_URL + "supplier/receiver/getdispensingaccount", params);
			JSONObject jsonObject = JSONObject.parseObject(result);
			if(jsonObject.getIntValue("errorCode") != 0){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			}else {
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
			}
			response.setMsg(jsonObject.getString("message"));
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg("发送对账数据给平台错误:" + e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;

	}


	/**
	 * 推送发药数据到平台
	 * @param params
	 * @return
	 */
	@RequestMapping("/pushDispensing")
	@ResponseBody
	public String pushDispensing(@RequestBody String params){
		logger.debug("推送发药数据:{}", params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("pushDispensing:(推送发药数据)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		try {
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_URL + "supplier/receiver/gethairtraceability", params);
			JSONObject jsonObject = JSONObject.parseObject(result);
			if(jsonObject.getIntValue("errorCode") != 0){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			}else {
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
			}
			response.setMsg(jsonObject.getString("message"));
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg("发送发药数据给平台错误:" + e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}


	/**
	 * 推送库存数据到平台
	 * @param params
	 * @return
	 */
	@RequestMapping("/pushStock")
	@ResponseBody
	public String pushStock(@RequestBody String params){
		logger.debug("推送库存数据:{}", params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("pushStock:(推送库存数据)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		try {
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_URL + "supplier/receiver/getreconciliation", params);
			JSONObject jsonObject = JSONObject.parseObject(result);
			if(jsonObject.getIntValue("errorCode") != 0){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			}else {
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
			}
			response.setMsg(jsonObject.getString("message"));
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg("发送库存数据给平台错误:" + e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
	
	/**
	 * 推送证照数据到平台
	 * @param params
	 * @return
	 */
	@RequestMapping("/pushlicinfo")
	@ResponseBody
	public String pushlicinfo(@RequestBody String params){
		logger.debug("证照数据:{}", params);
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		interfaceLogService.saveLog("pushDispensing:(推送证照数据)", params, logId);
		PlatFormResponse response = new PlatFormResponse();
		try {
			result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_SPD_Url + "saveresLic", params);//
			JSONObject jsonObject = JSONObject.parseObject(result);
			if(jsonObject.getIntValue("errorCode") != 0){
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			}else {
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
			}
			response.setMsg(jsonObject.getString("message"));
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg("发送证照数据给平台错误:" + e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
	
	
	/**
	 * 推送证照图片数据到平台
	 * @param params
	 * @return
	 */
	@RequestMapping("/pushlicpicinfo")
	@ResponseBody
	public String pushlicpicinfo(@RequestParam("file") MultipartFile file){
		String result = "";
		String logId = IdUtil.uuid();
		String exception = "";
		PlatFormResponse response = new PlatFormResponse();
		interfaceLogService.saveLog("pushDispensing:(推送证照数据)","filename////"+file.getOriginalFilename(), logId);
		try {
			 if (file!=null) {
				HttpClient client = HttpClients.createDefault();
				HttpPost post = new HttpPost(PlatformConstant.PlatForm_SPD_Url + "saveresLicpic");//
				File newfile = new File("/usr/local/img/"+file.getOriginalFilename());
			    file.transferTo(newfile);
			    FileBody bin = new FileBody(newfile);
				HttpEntity reqEntity = MultipartEntityBuilder.create().addPart("file", bin).build();
				post.setEntity(reqEntity);
				HttpResponse htppresponse = client.execute(post);
				HttpEntity resEntity = htppresponse.getEntity();
			    result = EntityUtils.toString(resEntity, "UTF-8");
			    JSONObject jsonObject = JSONObject.parseObject(result);
			    if(!"Y".equals(jsonObject.getString("FLAG"))){
					response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				}else {
					response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.success_ResultCode);
				}
				response.setMsg(jsonObject.toJSONString());
				if (newfile.exists()) {  
					newfile.delete();  
	            }  	 
			 }
			
		} catch (Exception e) {
			logger.error(e.getMessage());
			exception = e.getMessage();
			response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
			response.setMsg("发送证照图片数据给平台错误:" + e.getMessage());
			result = JSON.toJSONString(response);
		}
		interfaceLogService.setResultLog(response, logId, exception);
		return result;
	}
	
	
	
	  @RequestMapping(value="/CancelMedPlan")
	    @ResponseBody
	    public String CancelMedPlan(HttpServletRequest request, @RequestBody String param){
	    	logger.debug("补货计划作废接口请求参数:{}",param);
			String result = "";
			String logId = IdUtil.uuid();
			String exception = "";
			interfaceLogService.saveLog("CancelMedPlan:(补货计划作废接口)", param, logId);
			PlatFormResponse response = new PlatFormResponse();
			try {
				result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_HUARUN_Url+"CancelMedPlan", param);
				JSONObject jsonObject = JSONObject.parseObject(result);
				response.setFlag( jsonObject.getString("FLAG"));
				response.setMsg(jsonObject.getString("message"));			
			} catch (Exception e) {
				logger.error(e.getMessage());
				exception = e.getMessage();
				response.setFlag("E");
				response.setMsg(e.getMessage());
				result = JSON.toJSONString(response);
			}
			interfaceLogService.setResultLog(response, logId, exception);
			return result;
	    }
	
		/**
		 * 推送证照数据到平台
		 * @param params
		 * @return
		 */
		@RequestMapping("/doBarcode")
		@ResponseBody
		public String doBarcode(@RequestBody String params){
			logger.debug("供应商出库条码回传:{}", params);
			String result = "";
			String logId = IdUtil.uuid();
			String exception = "";
			interfaceLogService.saveLog("doBarcode:(供应商出库条码回传)", params, logId);
			PlatFormResponse response = new PlatFormResponse();
			try {
				result = HTTPClient.sendJsonDataByPost(PlatformConstant.PlatForm_SPD_Url + "doBarcode", params);//
				JSONObject jsonObject = JSONObject.parseObject(result);
				if(jsonObject.getString("FLAG") != null){
					response.setFlag(jsonObject.getString("FLAG"));
					response.setMsg(jsonObject.getString("MSG"));
				}else{
					response.setFlag("Y");
					response.setMsg("doBarcode:(供应商出库条码回传)返回值格式未对应");
				}
			} catch (Exception e) {
				logger.error(e.getMessage());
				exception = e.getMessage();
				response.setFlag(PlatFormResponseConstant.ResponseBodyMsg.fail_ResultCode);
				response.setMsg("doBarcode:(供应商出库条码回传)给SPD平台错误:" + e.getMessage());
				result = JSON.toJSONString(response);
			}
			interfaceLogService.setResultLog(response, logId, exception);
			return result;
		}
}