ps-inquiry/src/main/java/com/uas/ps/inquiry/service/impl/PublicInquiryServiceImpl.java

package com.uas.ps.inquiry.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.uas.ps.core.util.ContextUtils;
import com.uas.ps.entity.Product;
import com.uas.ps.entity.ProductUsers;
import com.uas.ps.entity.Status;
import com.uas.ps.inquiry.AccessConfiguration;
import com.uas.ps.inquiry.dao.*;
import com.uas.ps.inquiry.domain.IPage;
import com.uas.ps.inquiry.entity.*;
import com.uas.ps.inquiry.model.*;
import com.uas.ps.inquiry.page.PageInfo;
import com.uas.ps.inquiry.page.SearchFilter;
import com.uas.ps.inquiry.page.criteria.CriterionExpression;
import com.uas.ps.inquiry.page.criteria.LogicalExpression;
import com.uas.ps.inquiry.page.criteria.PredicateUtils;
import com.uas.ps.inquiry.page.criteria.SimpleExpression;
import com.uas.ps.inquiry.service.PublicInquiryService;
import com.uas.ps.inquiry.util.*;
import javassist.NotFoundException;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.ui.ModelMap;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.persistence.criteria.*;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 公共询价接口实现
 *
 * Created by hejq on 2018-01-13.
 */
@Service
public class PublicInquiryServiceImpl implements PublicInquiryService {

    @Autowired
    private PublicInquiryDao publicInquiryDao;

    @Autowired
    private PurcInquiryDao purcInquiryDao;

    @Autowired
    private ProductDao productDao;

    @Autowired
    private PurcInquiryItemDao purcInquiryItemDao;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private PublicInquiryReplyDao publicInquiryReplyDao;

    @Autowired
    private PurcInquiryItemInfoDao inquiryItemInfoDao;

    @Autowired
    private PublicInquiryItemInfoDao  itemInfoDao;

    @Autowired
    private PublicInquiryItemDao publicInquiryItemDao;

    @Autowired
    private UserDao userDao;

    @Autowired
    private EnterpriseDao enterpriseDao;

    @Autowired
    private InquiryRemindDao remindDao;

    private static final Logger logger = Logger.getLogger(Logger.class);

    /**
     * 应用来源
     */
    private final String SOURCERAPP = "B2B";

    /**
     * 询价种类
     */
    private final String INQUIRYKIND = "publicInquiry";

    /**
     * 消息推送邮件模板id
     */
    private final String MAIL_TEMP_ID = "d94e931b-b699-46d7-8bb2-94604a3352c0";

    /**
     * 消息推送短信模板id
     */
    private final String SMS_TEMP_ID = "e14d502a-25b8-40a0-8acf-5c61ae38d763";

    /**
     * 消息推送方式：邮件、短信、im
     */
    private final String SMS_TYPE = "MAIL_AND_SM_AND_IM";

    /**
     * 来源应用，ERP
     */
    private final String PRODUCERAPP = "ERP";

    /**
     * 消费类型： 多个，MULTI
     */
    private final String CUST_TYPE = "MULTI";

    /**
     * 接收应用
     */
    private final String CONSUMERAPP = "B2B,MALL";

    /**
     * 公共物料访问地址
     */
    private final String PS_PRODUCT_URL = ContextUtils.getBean(AccessConfiguration.class).getPsProductUrl();

    /**
     * 公共消息访问地址
     */
    private final String PS_MESSAGE_URL = ContextUtils.getBean(AccessConfiguration.class).getPsMessageUrl();

    /**
     * 保存公共询价信息
     *
     * @param inquiries erp传入公共询价的信息
     * @param enuu 询价企业UU号
     * @param address 询价企业地址
     */
    @Override
    public void save(List<BatchInquiry> inquiries, Long enuu, String address) throws NotFoundException {
        List<PurcInquiry> purcInquiries = covert(inquiries, enuu, address);
        List<PurcInquiryItem> inquiryItems = new ArrayList<>();
        if(!CollectionUtils.isEmpty(purcInquiries)) {
            for(PurcInquiry inquiry : purcInquiries) {
                // 判断单号是否已存在
                PurcInquiry old = purcInquiryDao.findByCodeAndEnUU(inquiry.getCode(), enuu);
                List<PurcInquiryItem> items = new ArrayList<PurcInquiryItem>();
                if(old == null && !CollectionUtils.isEmpty(inquiry.getInquiryItems())) {
                    for(PurcInquiryItem item : inquiry.getInquiryItems()) {
                        item.setInquiry(inquiry);
                        items.add(item);
                    }
                }
                try {
                    items = purcInquiryItemDao.save(items);
                    inquiryItems.addAll(items);
                    if (!CollectionUtils.isEmpty(inquiryItems)) {
                        notify(inquiryItems, PRODUCERAPP);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 消息推送
     *
     * @param inquiryItems 询价明细
     * @param sourceApp 消息来源应用
     */
    @Override
    public void notify(List<PurcInquiryItem> inquiryItems, String sourceApp) throws Exception {
        for (PurcInquiryItem item : inquiryItems) {
            Product product = productDao.findOne(item.getProductId());
            if (null == product) {
                throw new NotFoundException("询价单" + item.getInquiry().getCode() + "，明细第" + item.getNumber() + "行未找到对应物料");
            }
            String url = PS_PRODUCT_URL + "/productuser/getProductUsersByEnUUAndCmpCode";
            JSONObject formData = new JSONObject();
            formData.put("enUU", item.getInquiry().getEnUU());
            formData.put("cmpCode", item.getCmpCode());
            try {
                HttpUtil.Response res = HttpUtil.sendGetRequest(url, formData);
                if (res.getStatusCode() == 200) {
                    List<ProductUsers> users = FlexJsonUtils.fromJsonArray(res.getResponseText(), ProductUsers.class);
                    if (!CollectionUtils.isEmpty(users)) {
                        List<MessageModel> models = new ArrayList<MessageModel>();
                        for (ProductUsers user : users) {
                            User u = userDao.findOne(user.getUseruu());
                            Enterprise e = enterpriseDao.findOne(user.getEnuu());
                            String content = "发布关于“" + product.getTitle() + "”的公共询价信息，邀请您参与报价";
                            if (null != e) {
                                u.setEnterprise(e);
                                content = e.getEnName() + content;
                            } else if (null == e && null != u) {
                                content = u.getUserName() + content;
                            }
                            MessageModel model = new MessageModel();
                            model.setProducerApp(sourceApp);
                            model.setConsumerType(CUST_TYPE);
                            model.setConsumerApp(CONSUMERAPP);
                            model.setContent(content);
                            model.setRemark(product.getCmpCode());
                            model.setReceiverEnuu(user.getEnuu());
                            model.setReceiverUu(user.getUseruu());
                            model.setSenderEnuu(item.getInquiry().getEnUU());
                            if (null != item.getUserUU() || null != item.getInquiry().getRecorderUU()) {
                                model.setSenderUu(item.getUserUU() != null ? item.getUserUU() : item.getInquiry().getRecorderUU());
                            } else {
                               Enterprise enterprise = enterpriseDao.findOne(item.getInquiry().getEnUU());
                               model.setSenderUu(null != enterprise ? enterprise.getAdminUU() : 0L);
                            }
                            model.setSmsType(SMS_TYPE);
                            model.setMailTemplate(MAIL_TEMP_ID);
                            model.setSmTemplate(SMS_TEMP_ID);
                            models.add(model);
                        }
                        if (!CollectionUtils.isEmpty(models)) {
                            sendMessage(models);
                        }

                        // 生成推荐信息
                        remindInquiry(inquiryItems, users);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 通过查询的个人物料相关联的信息，自动生成推荐的报价的数据
     *
     * @param inquiryItems 报价明细
     * @param users 用户信息
     */
    private void remindInquiry(final List<PurcInquiryItem> inquiryItems, final List<ProductUsers> users) {
        ThreadUtils.task(new Runnable() {
            @Override
            public void run() {
                try {
                    List<InquiryRemind> reminds = new ArrayList<InquiryRemind>();
                    for (ProductUsers u : users) {
                        for (PurcInquiryItem item : inquiryItems) {
                            if (item.getInquiry().getEnUU() != null) {
                                Enterprise enterprise = enterpriseDao.findOne(item.getInquiry().getEnUU());
                                InquiryRemind remind = new InquiryRemind();
                                remind.setEnName(enterprise.getEnName());
                                remind.setEnUU(item.getInquiry().getEnUU());
                                remind.setUserName(item.getUserName());
                                remind.setUserTel(item.getUserTel());
                                remind.setCode(item.getInquiry().getCode());
                                remind.setBrand(item.getBrand());
                                remind.setCmpCode(item.getCmpCode());
                                remind.setSpec(item.getSpec());
                                remind.setTitle(item.getProdTitle());
                                if (item.getProduct() != null) {
                                    remind.setBrand(item.getProduct().getBrand());
                                    remind.setCmpCode(item.getProduct().getCmpCode());
                                    remind.setSpec(item.getProduct().getSpec());
                                    remind.setTitle(item.getProduct().getTitle());
                                }
                                remind.setItemId(item.getId());
                                remind.setNeedQty(item.getNeedquantity());
                                remind.setReDate(item.getInquiry().getDate());
                                remind.setEndDate(item.getInquiry().getEndDate());
                                remind.setVendUU(u.getEnuu());
                                remind.setVendUserUU(u.getUseruu());
                                remind.setDate(new Date(System.currentTimeMillis()));
                                remind.setStatus(Status.INPUTTING.value());
                                reminds.add(remind);
                            }

                        }
                    }
                    if (!CollectionUtils.isEmpty(reminds)) {
                        remindDao.save(reminds);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).run();
    }

    /**
     * 通过id查询询价信息
     *
     * @param id 公共询价主表id
     * @return
     */
    @Override
    public PurcInquiry findInquiryById(Long id) {
        return purcInquiryDao.findOne(id);
    }

    /**
     * 发送消息推送
     *
     * @param models 封装的消息信息
     */
    private void sendMessage(final List<MessageModel> models) {
        ThreadUtils.task(new Runnable() {
            @Override
            public void run() {
                try {
                    logger.info("发送消息实体" + JSON.toJSONString(models));
                    String res = HttpUtil.doPost(PS_MESSAGE_URL + "/messages", FlexJsonUtils.toJsonDeep(models));
                    logger.info("消息请求发送日志" + res);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).run();
    }

    /**
     * 将ERP传入的inquiry信息转成公共询价服务中心需要的信息
     *
     * @param inquiries 将ERP传入的inquiry信息
     * @param enuu 询价企业UU号
     * @param address 询价企业地址
     * @return
     */
    @Override
    public List<PurcInquiry> covert(List<BatchInquiry> inquiries, Long enuu, String address) throws NotFoundException {
        List<PurcInquiry>  purcInquiries = new ArrayList<PurcInquiry>();
        if (!CollectionUtils.isEmpty(inquiries)) {
            for (BatchInquiry inquiry : inquiries) {
                PurcInquiry old = purcInquiryDao.findByCodeAndEnUU(inquiry.getBi_code(), enuu);
                //先判断是否已经存在,不存在才进行存储
                if (null == old) {
                    PurcInquiry purcInquiry = inquiry.covert();
                    purcInquiry.setEnUU(enuu);
                    purcInquiry.setShip(address);
                    Set<PurcInquiryItem> purcInquiryItems = new HashSet<PurcInquiryItem>();
                    if (!CollectionUtils.isEmpty(inquiry.getInProducts())) {
                        for(BatchInProduct batch : inquiry.getInProducts()) {
                            PurcInquiryItem item = new PurcInquiryItem();
                            item.setIsOpen(Constant.YES);
                            List<Product> products = productDao.findByEnUUAndCode(enuu, batch.getBip_prodcode());
                            if (CollectionUtils.isEmpty(products)) {
                                throw new NotFoundException("编号为[" + batch.getBip_prodcode() + "]的物料未找到");
                            }
                            item.setProductId(products.get(0).getId());
                            item.setCmpCode(products.get(0).getCmpCode());
                            item.setInbrand(products.get(0).getBrand());
                            item.setProdTitle(products.get(0).getTitle());
                            item.setSpec(products.get(0).getSpec());
                            item.setRemark(batch.getBip_remark());
                            item.setProdCode(products.get(0).getCode());
                            item.setProdTitle(products.get(0).getTitle());
                            item.setNumber(batch.getBip_detno());
                            item.setFromDate(new Date());
                            item.setToDate(purcInquiry.getEndDate());
                            item.setStatus((short) Status.NOT_REPLY.value());
                            item.setIsOpen(Constant.YES);
                            item.setSource("ERP");
                            item.setSourceid(batch.getBip_id());
                            item.setCurrency(batch.getBip_currency());
                            item.setUserName(batch.getEm_name());
                            item.setUserTel(batch.getBip_mobile());
                            item.setUserCode(batch.getBip_buyercode());
                            item.setOfferAmount(0);
                            if (null != inquiry.getBi_date()) {
                                item.setDate(inquiry.getBi_date());
                            } else {
                                item.setDate(new Date(System.currentTimeMillis()));
                            }
                            if (item.getCurrency() == null) {
                                item.setCurrency("RMB");
                            }
                            purcInquiryItems.add(item);
                        }
                    }
                    purcInquiry.setInquiryItems(purcInquiryItems);
                    purcInquiries.add(purcInquiry);
                }
            }
        }
        return purcInquiries;
    }

    /**
     * erp提交审核时，公共询价服务中心单据禁用报价功能
     *
     * @param inquiries erp询价信息
     * @param enuu 询价企业UU号
     */
    @Override
    public void updateStatus(List<BatchInquiry> inquiries, Long enuu) {
        if (!CollectionUtils.isEmpty(inquiries)) {
            for (BatchInquiry inquiry : inquiries) {
                PurcInquiry purcInquiry = purcInquiryDao.findByCodeAndEnUU(inquiry.getBi_code(), enuu);
                purcInquiryItemDao.updateStatus(purcInquiry.getId());
            }
        }
    }

    /**
     * 查询供应商的报价信息
     *
     * @return
     */
    @Override
    public List<InquiryDetail> findNotUploadReply(Long enuu) {
        List<PublicInquiryItem> items =  publicInquiryItemDao.findByEnUUAndBackStatus(enuu, (short) Status.NOT_UPLOAD.value());
        if (!CollectionUtils.isEmpty(items)) {
            // 防止下载过程中进行操作，这里设置一个下载中的状态
            Set<Long> ids = new HashSet<>();
            for (PublicInquiryItem item : items) {
                ids.add(item.getId());
            }
            if (ids.size() > 0) {
                publicInquiryItemDao.updateBackStatus(ids);
            }
            return convertPublicInquiryReply(items);
        }
        return null;
    }

    /**
     * 将公共询价服务中心的公共询价转成ERP的对应的字段
     *
     * @param notUploadReply 未下载的供应商报价信息
     * @return
     * @author hejq
     * @date 2018-01-14 11:51
     */
    @Override
    public List<InquiryDetail> convertPublicInquiryReply(List<PublicInquiryItem> notUploadReply) {
        List<InquiryDetail> details = new ArrayList<InquiryDetail>();
        if (!CollectionUtils.isEmpty(notUploadReply)) {
            for (PublicInquiryItem item : notUploadReply) {
                details.add(new InquiryDetail(item));
            }
        }
        return details;
    }

    /**
     * 下载完成后更新公共询价服务中心询价单明细的下载状态
     *
     * @param idArray 询价单明细id
     * @author hejq
     * @date 2018-01-14 12:12
     */
    @Override
    public void onReplyUploadSuccess(String[] idArray) {
        for (String id : idArray) {
            PublicInquiryItem item = publicInquiryItemDao.findOne(Long.parseLong(id));
            if (item != null) {
                item.setBackStatus((short) Status.DOWNLOADED.value());
                item.setErpstatus(Constant.YES);
                publicInquiryItemDao.save(item);
            }
        }
    }

    /**
     * ERP提交公共询价单之后，更新平台状态，让公共询价服务中心询价单不能进行报价操作
     *
     * @param inquiries 询价信息
     * @author hejq
     * @date 2018-01-14 12:20
     */
    @Override
    public void updateInquiryStatus(List<Inquiry> inquiries) {
        if(!CollectionUtils.isEmpty(inquiries)) {
            for(Inquiry inquiry : inquiries) {
                // 更新为过期状态，不能进行报价处理
                String sql = "update purc$puinquiryitems set id_overdue = 1 where id_inid in ( select in_id from purc$puinquiry where in_enuu = "
                        + inquiry.getEn_uu() + " and in_code = '" + inquiry.getIn_code() + "')";
                jdbcTemplate.update(sql);
                // 更新已转报价的询价单明细状态
                jdbcTemplate.update("update public$inquiryItems set id_overdue = 1 where id_inid in " +
                        "(select in_id from public$inquiry where in_enuu = " + inquiry.getEn_uu() + " and in_code = '" + inquiry.getIn_code() + "')");
                // 更新已转报价的询价单主表check状态为已提交
                jdbcTemplate.update("update public$inquiry set in_checked = 1 where in_enuu = " + inquiry.getEn_uu() + " and in_code = '" + inquiry.getIn_code() + "'");
            }
        }
    }

    /**
     * ERP对报价信息的采纳状态上传到公共询价服务中心
     *
     * @param decides 采纳信息
     */
    @Override
    public void onReplyDecide(List<InquiryDecide> decides, Long enuu) {
        List<PublicInquiryItem> publicInquiryItems = convertInquiryDecide(decides);
        if (!CollectionUtils.isEmpty(publicInquiryItems)) {
            for (PublicInquiryItem inquiryItem : publicInquiryItems) {
                publicInquiryItemDao.updateDecideStatusByID(inquiryItem.getAgreed(), inquiryItem.getDecideStatus(), inquiryItem.getId());
            }
        }
    }

    /**
     * 将ERP的报价采纳信息转为公共询价服务中心需要的信息
     *
     * @param decides erp报价采纳信息
     * @author hejq
     * @date 2018-01-14 12:25
     */
    @Override
    public List<PublicInquiryItem> convertInquiryDecide(List<InquiryDecide> decides) {
        List<PublicInquiryItem> inquiryItems = new ArrayList<PublicInquiryItem>();
        if (!CollectionUtils.isEmpty(decides)) {
            for (InquiryDecide decide : decides) {
                PublicInquiryItem item = publicInquiryItemDao.findOne(decide.getB2b_id());
                if (null != item) {
                    item.setAgreed(decide.getId_agreed());
                    item.setDecideStatus((short) Status.NOT_UPLOAD.value());
                    inquiryItems.add(item);
                }
            }
        }
        return inquiryItems;
    }

    /**
     * 买家ERP作废询价单后，修改公共询价服务中心里面的状态
     *
     * @param inquiries 询价信息
     * @param enuu 企业UU
     * @author hejq
     * @date 2018-01-14 12:28
     */
    @Override
    public void onReplyInvalid(List<Inquiry> inquiries, final Long enuu) {
        final List<PublicInquiryItem> newInquiryItems = new ArrayList<>();
        ThreadUtils.tasks(new IRunnable<Inquiry>() {

            @Override
            public void run(Inquiry inquiry) {
                List<PublicInquiry> purchaseInquiries = publicInquiryDao.findByEnUUAndCode(enuu, inquiry.getIn_code());
                if (!CollectionUtils.isEmpty(purchaseInquiries)) {
                    PublicInquiry publicInquiry = purchaseInquiries.get(0);
                    for (PublicInquiryItem item : publicInquiry.getInquiryItems()) {
                        item.setStatus((short) Status.DISABLED.value());
                        // 获取作废信息时，更新作废上传状态为 待上传
                        item.setInvalidStatus((short) Status.NOT_UPLOAD.value());
                        synchronized (newInquiryItems) {
                            newInquiryItems.add(item);
                        }
                    }
                }
            }

        }, inquiries).run();
    }

    /**
     * 将公共询价列表转成需要报价的询价单，类型是公共询价
     *
     * @param id     询价明细id
     * @param enuu   报价企业UU
     * @param useruu 报价人uu
     * @return
     * @author hejq
     * @date 2018-01-14 14:46
     */
    @Override
    public ModelMap transtoInquiry(Long id, Long enuu, Long useruu) {
        ModelMap map = new ModelMap();
        PurcInquiryItem purcInquiryItem = purcInquiryItemDao.findOne(id);
        PurcInquiry purcInquiry = purcInquiryItem.getInquiry();
        // 先判断客户询价单是否存在这张单据
        PublicInquiry inquiry = publicInquiryDao.findBySourceIdAndSourceApp(purcInquiry.getId(), SOURCERAPP);
        if (null == inquiry) {// 新增
            PublicInquiry saleInquiry = new PublicInquiry();
            saleInquiry.setDate(new Date());
            saleInquiry.setCode(purcInquiry.getCode());
            saleInquiry.setEnUU(purcInquiry.getEnUU());
            saleInquiry.setRecorder(purcInquiry.getRecorder());
            saleInquiry.setRecorderUU(purcInquiry.getRecorderUU());
            saleInquiry.setAuditor(purcInquiry.getAuditor());
            saleInquiry.setSourceApp(SOURCERAPP);
            saleInquiry.setKind(INQUIRYKIND);
            saleInquiry.setSourceId(purcInquiry.getId());
            saleInquiry.setPriceType(purcInquiry.getPriceType());
            saleInquiry.setInvoice(purcInquiry.getInvoice());
            saleInquiry.setShip(purcInquiry.getShip());
            saleInquiry.setEndDate(purcInquiry.getEndDate());
            if (!CollectionUtils.isEmpty(purcInquiry.getAttachs())) {
                Set<com.uas.ps.inquiry.model.Attach> attachs = new HashSet<com.uas.ps.inquiry.model.Attach>();
                for (com.uas.ps.inquiry.model.Attach attach : purcInquiry.getAttachs()) {
                    com.uas.ps.inquiry.model.Attach newAttach = new com.uas.ps.inquiry.model.Attach();
                    newAttach.setDate(new Date());
                    newAttach.setDescription(attach.getDescription());
                    newAttach.setName(attach.getName());
                    newAttach.setPath(attach.getPath());
                    newAttach.setRelatedKey(attach.getRelatedKey());
                    newAttach.setSize(attach.getSize());
                    newAttach.setRelatedKey(attach.getRelatedKey());
                    attachs.add(newAttach);
                }
                saleInquiry.setAttachs(attachs);

            }
            saleInquiry.setEnvironment(purcInquiry.getEnvironment());
            saleInquiry.setRemark(purcInquiry.getRemark());
            saleInquiry.setInquirytype(purcInquiry.getInquirytype());
            Set<PublicInquiryItem> items = new HashSet<PublicInquiryItem>();
            Short i = 0;
            if (null != purcInquiryItem) {
                PublicInquiryItem item = new PublicInquiryItem();
                Product product = productDao.findOne(purcInquiryItem.getProductId());
                item.setProductId(product.getId());
                item.setInquiry(saleInquiry);
                item.setNumber(i);
                item.setCurrency(purcInquiryItem.getCurrency());
                item.setFromDate(new Date());
                item.setToDate(purcInquiryItem.getToDate());
                item.setTaxrate(purcInquiryItem.getTaxrate());
                item.setRemark(purcInquiryItem.getRemark());
                item.setProductId(purcInquiryItem.getProductId());
                item.setStatus((short) Status.NOT_REPLY.value());
                item.setVendUU(enuu);
                item.setVendUserUU(useruu);
                item.setSource(purcInquiryItem.getSource());
                item.setCustLap(Constant.NO);
                item.setSendStatus((short) Status.NOT_UPLOAD.value());
                item.setSourceId(id);
                List<PublicInquiryReply> replies = new ArrayList<PublicInquiryReply>();
                PublicInquiryReply reply = new PublicInquiryReply();
                reply.setLapQty((double) 0);
                replies.add(reply);
                item.setReplies(replies);
                item.setNeedquantity(purcInquiryItem.getNeedquantity());
                item.setKind(INQUIRYKIND);
                item.setProdCode(purcInquiryItem.getProdCode());
                items.add(item);
                i++;
            }
            List<PublicInquiryItem> purcitems = publicInquiryItemDao.save(items);
            if (purcitems.get(0).getId() != null) {
                map.put("success", "转客户询价单成功");
                map.put("id", purcitems.get(0).getInquiry().getId());
            } else {
                map.put("success", "转客户询价单失败");
            }
        } else {// 插入
            PublicInquiryItem purcItem = publicInquiryItemDao.findByVendUUAndSourceId(enuu, id);
            if (purcItem != null) {
                map.put("info", "询价单已存在");
                map.put("inid", purcItem.getId());
            } else {
                if (!CollectionUtils.isEmpty(purcInquiry.getInquiryItems())) {
                    if (null != purcInquiryItem) {
                        // 涉及到级联存储及ERP转入单据的操作，用主表id存储存在问题，这里先用sql语句直接插入
                        PublicInquiryItem item = new PublicInquiryItem();
                        Product product = productDao.findOne(purcInquiryItem.getProductId());
                        item.setProductId(product.getId());
                        item.setNumber((short) (purcInquiry.getInquiryItems().size() + 1));
                        item.setCurrency(purcInquiryItem.getCurrency());
                        item.setFromDate(new Date());
                        item.setToDate(purcInquiryItem.getToDate());
                        item.setTaxrate(purcInquiryItem.getTaxrate());
                        item.setRemark(purcInquiryItem.getRemark());
                        item.setProductId(purcInquiryItem.getProductId());
                        item.setVendUU(enuu);
                        item.setVendUserUU(useruu);
                        item.setSource(purcInquiryItem.getSource());
                        item.setStatus((short) Status.NOT_REPLY.value());
                        item.setCustLap(Constant.NO);
                        item.setSendStatus((short) Status.NOT_UPLOAD.value());
                        item.setSourceId(id);
                        item.setProdCode(purcInquiryItem.getProdCode());
                        item.setKind(INQUIRYKIND);
                        item.setNeedquantity(purcInquiryItem.getNeedquantity());
                        List<PublicInquiryReply> replies = new ArrayList<PublicInquiryReply>();
                        List<PublicInquiryReply> purcReplies = new ArrayList<PublicInquiryReply>();
                        PublicInquiryReply reply = new PublicInquiryReply();
                        reply.setLapQty((double) 0);
                        purcReplies.add(reply);
                        purcReplies = publicInquiryReplyDao.save(purcReplies);
                        replies.addAll(purcReplies);
                        item.setReplies(replies);
                        Long idid = jdbcTemplate.queryForObject("select public$inquiryitems_seq.nextval from dual", Long.class);
                        try {
                            jdbcTemplate.update(
                                    "insert into public$inquiryitems(id_id,id_number,id_currency,id_fromdate,id_todate,id_taxrate,id_prid,id_venduu,"
                                            + "id_venduseruu,id_sourceapp,id_status,id_custlap,id_sendstatus,id_sourceid,id_inid,id_kind) values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
                                    idid, item.getNumber(), item.getCurrency(), item.getFromDate(), item.getToDate(),
                                    item.getTaxrate(), item.getProductId(), item.getVendUU(), item.getVendUserUU(),
                                    item.getSource(), item.getStatus(), item.getCustLap(), item.getSendStatus(),
                                    item.getSourceId(), inquiry.getId(), inquiry.getKind());
                        } catch (DataAccessException e) {
                            map.put("info", "转客户询价单失败");
                        }
                        item = publicInquiryItemDao.findOne(idid);
                        //回复清单更新
                        if(replies.size() > 0) {
                            for (PublicInquiryReply reply1 : replies) {
                                jdbcTemplate.update("update public$inquiryreply set ir_idid = " + idid + "where ir_id = " + reply1.getId());
                            }
                        }
                        if (item != null) {
                            map.put("success", "转客户询价单成功");
                            map.put("id", item.getInquiry().getId());
                        } else {
                            map.put("info", "转客户询价单失败");
                        }
                    }
                }
            }

        }
        return map;
    }

    /**
     * 通过分页参数和过滤条件查询报价信息
     *
     * @param info   分页参数
     * @param filter 过滤条件
     * @return
     * @author hejq
     * @date 2018-01-17 10:30
     */
    @Override
    public Page<PublicInquiryItemInfo> findByPageInfo(final PageInfo info, final SearchFilter filter) {
        if (null != filter) {
            if (StringUtils.hasText(filter.getKeyword())) {
                SimpleExpression title = new SimpleExpression("product.title", filter.getKeyword(), CriterionExpression.Operator.LIKE, true);
                SimpleExpression code = new SimpleExpression("product.code", filter.getKeyword(), CriterionExpression.Operator.LIKE, true);
                SimpleExpression spec = new SimpleExpression("product.spec", filter.getKeyword(), CriterionExpression.Operator.LIKE, true);
                SimpleExpression brand = new SimpleExpression("product.brand", filter.getKeyword(), CriterionExpression.Operator.LIKE, true);
                SimpleExpression[] simpleExpressions = new SimpleExpression[]{title, brand, code, spec};
                LogicalExpression logical = new LogicalExpression(simpleExpressions, CriterionExpression.Operator.OR);
                info.expression(logical);
            }
            if (filter.getFromDate() != null) {
                info.expression(PredicateUtils.gte("offerTime", new Date(filter.getFromDate()), false));
            }
            if (filter.getEndDate() != null) {
                info.expression(PredicateUtils.lte("offerTime", new Date(filter.getEndDate()), false));
            }
        }
        return itemInfoDao.findAll(new Specification<PublicInquiryItemInfo>() {
            public Predicate toPredicate(Root<PublicInquiryItemInfo> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
                query.where(info.getPredicates(root, query, builder));
                return null;
            }
        }, info);
    }

    /**
     * 查询公共询价列表信息
     *
     * @param info 分页参数
     * @param filter 过滤条件
     * @return
     */
    @Override
    public IPage<PurcInquiryItemInfo> findTodoByPageInfo(final PageInfo info, final SearchFilter filter) {
        Page<PurcInquiryItemInfo> orders =  inquiryItemInfoDao.findAll(new Specification<PurcInquiryItemInfo>() {
            public Predicate toPredicate(Root<PurcInquiryItemInfo> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
                if (null != filter) {
                    if (filter.getFromDate() != null) {
                        info.expression(PredicateUtils.gte("date", new Date(filter.getFromDate()), false));
                    }
                    if (filter.getEndDate() != null) {
                        info.expression(PredicateUtils.lte("date", new Date(filter.getEndDate()), false));
                    }
                    if (!StringUtils.isEmpty(filter.getKeyword())) {
                        SimpleExpression cmpCode = new SimpleExpression("cmpCode", filter.getKeyword(), CriterionExpression.Operator.LIKE);
                        SimpleExpression brand = new SimpleExpression("inbrand", filter.getKeyword(), CriterionExpression.Operator.LIKE);
                        SimpleExpression code = new SimpleExpression("product.cmpCode", filter.getKeyword(), CriterionExpression.Operator.LIKE);
                        SimpleExpression[] simpleExpressions = new SimpleExpression[]{cmpCode, brand, code};
                        LogicalExpression logicalExpression = PredicateUtils.or(simpleExpressions);
                        info.expression(logicalExpression);
                    }
                }
                query.where(info.getPredicates(root, query, builder));
                return null;
            }
        }, info);
        return covert(orders, filter.getEnUU());
    }

    /**
     * 将数据库查询的数据进行封装处理
     *
     * @param orders 查询的数据信息
     * @return
     */
    private IPage<PurcInquiryItemInfo> covert(Page<PurcInquiryItemInfo> orders, Long enuu) {
        if (!CollectionUtils.isEmpty(orders.getContent()) && null != enuu) {
            for (PurcInquiryItemInfo itemInfo : orders.getContent()) {
                PublicInquiryItem item = publicInquiryItemDao.findByVendUUAndSourceId(enuu, itemInfo.getId());
                itemInfo.setQuoted(Constant.NO);
                if (null != item) {
                    itemInfo.setAgreed(item.getAgreed());
                    itemInfo.setQuteId(item.getId());
                    itemInfo.setQuoted(Constant.YES);
                }
            }
        }
        return IPageUtils.covert(orders);
    }

    /**
     * 根据传入条件封装查询条件
     *
     * @param pageInfo 分页参数
     * @param state    过滤条件
     * @return
     */
    @Override
    public PageInfo covert(PageInfo pageInfo, String state) {
        if (state.equals(OrderStatus.todo.name())) {
            pageInfo.filter("status", Status.NOT_REPLY.value());
            pageInfo.filter("overdue", Constant.NO);
            pageInfo.filter("invalid", Constant.NO);
        } else if (state.equals(OrderStatus.done.name())) {
            pageInfo.filter("overdue", Constant.NO);
            pageInfo.filter("status", Status.REPLIED.value());
            pageInfo.filter("invalid", Constant.NO);
            pageInfo.filter("decideStatus", Status.UNAUDIT.value());
        } else if (state.equals(OrderStatus.end.name())) {
            pageInfo.filter("overdue", Constant.YES);
            pageInfo.filter("invalid", Constant.NO);
        } else if (state.equals(OrderStatus.invalid.name())) {
            pageInfo.filter("overdue", Constant.YES);
            pageInfo.filter("invalid", Constant.YES);
        } else if (state.equals(OrderStatus.agreed.name())) {
            pageInfo.filter("agreed", Constant.YES);
            pageInfo.filter("status", Status.REPLIED.value());
            pageInfo.filter("invalid", Constant.NO);
        } else if (state.equals(OrderStatus.refused.name())) {
            pageInfo.filter("agreed", Constant.NO);
            pageInfo.filter("status", Status.REPLIED.value());
            pageInfo.filter("invalid", Constant.NO);
        }
        return pageInfo;
    }

    /**
     * 获取公共询价列表信息
     *
     * @param enuu 当前企业UU
     * @param size 大小
     * @return
     */
    @Override
    public List<InquiryMessage> getMessageList(Long enuu, Integer size) {
        if (size == 0 || size == null) {
            size = 10;
        }
        String sql = "select * from (select p.id_id id, p.id_prid productId, p.id_date as date, i.in_enuu enuu from purc$puinquiryitems p left join purc$puinquiry i on i.in_id = p.id_inid where i.in_isopen = 1";
        if (enuu != null) {
            sql = sql + " and i.in_enuu <> " + enuu ;
        }
        sql = sql + " and COALESCE(p.id_overdue, 0) <> 1 order by p.id_id desc) i limit " + size;
        List<PurcInquiryItem> items = jdbcTemplate.query(sql, new BeanPropertyRowMapper<PurcInquiryItem>(PurcInquiryItem.class));
        List<InquiryMessage> messages = new ArrayList<InquiryMessage>();
        if (!CollectionUtils.isEmpty(items)) {
            for (PurcInquiryItem item : items) {
                InquiryMessage message = new InquiryMessage();
                if (null != item.getEnuu()) {
                    Enterprise enterprise = enterpriseDao.findOne(item.getEnuu());
                    message.setEnName(enterprise.getEnName());
                }
                Product prod = productDao.findOne(item.getProductId());
                message.setPordName(prod.getTitle());
                item = purcInquiryItemDao.findOne(item.getId());
                message.setInid(item.getId());
                PublicInquiryItem publicInquiryItem = publicInquiryItemDao.findByVendUUAndSourceId(enuu, item.getId());
                if (null != publicInquiryItem) {
                    message.setQuteId(publicInquiryItem.getId());
                }
                message.setLastest(isToday(item.getDate()));
                messages.add(message);
            }
        }
        return messages;
    }

    /**
     * 判断该条单据是否当天单据
     *
     * @param date 询价时间
     * @return
     */
    private boolean isToday(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String inDate = sdf.format(date);
        String nowDate = sdf.format(new Date());
        return inDate.equals(nowDate);
    }
}