针对客户供应商搜索查询公共询价单，及针对公共询价单做的操作后台方法

src/main/java/com/uas/platform/b2b/controller/PubInquiryController.java

@@ -0,0 +1,574 @@
+package com.uas.platform.b2b.controller;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.uas.platform.b2b.model.FileUpload;
+import com.uas.platform.b2b.model.PublicInquiryItem;
+import com.uas.platform.b2b.model.PublicInquiryItemInfo;
+import com.uas.platform.b2b.model.SearchFilter;
+import com.uas.platform.b2b.search.SearchService;
+import com.uas.platform.b2b.service.PubInquiryService;
+import com.uas.platform.b2b.service.UserService;
+import com.uas.platform.b2b.support.SystemSession;
+import com.uas.platform.b2b.support.TokenService;
+import com.uas.platform.b2b.support.UsageBufferedLogger;
+import com.uas.platform.core.exception.IllegalOperatorException;
+import com.uas.platform.core.logging.BufferedLoggerManager;
+import com.uas.platform.core.model.Constant;
+import com.uas.platform.core.model.PageInfo;
+import com.uas.platform.core.model.PageParams;
+import com.uas.platform.core.model.Status;
+import com.uas.platform.core.util.serializer.FlexJsonUtils;
+import com.uas.platform.core.web.bind.RequestState;
+import com.uas.search.b2b.model.MultiValue;
+import com.uas.search.b2b.model.SPage;
+import com.uas.search.b2b.model.Sort;
+import com.uas.search.b2b.util.SearchConstants;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.ui.ModelMap;
+import org.springframework.util.CollectionUtils;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * 公共询价（针对供应商）
+ *
+ * Created by hejq on 2018-01-06.
+ */
+@RequestMapping("/sale/pubInquiry")
+@RestController
+public class PubInquiryController {
+
+    private final static UsageBufferedLogger logger = BufferedLoggerManager.getLogger(UsageBufferedLogger.class);
+
+    @Autowired
+    private PubInquiryService pubInquiryService;
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private SearchService searchService;
+
+    @Autowired
+    private TokenService tokenService;
+
+    /**
+     * 转成客户询价单
+     *
+     * @param id 公共询价明细id
+     * @return
+     */
+    @RequestMapping(value = "/turntoInquiry/{id}", method = RequestMethod.POST)
+    private ModelMap transtoInquiry(@PathVariable Long id) {
+        logger.log("公共询价单", "将公共询价单（" + id + ")转成询价报价单");
+        return pubInquiryService.transtoInquiry(id);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（全部）不搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiries(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（全部）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("vendUU", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        SearchFilter distribute = userService.distribute();
+        if (distribute != null && distribute.getDistribute() == null) {
+            return null;
+        }
+        if (distribute != null && !CollectionUtils.isEmpty(distribute.getDistribute())) {
+            filter.setDistribute(distribute.getDistribute());
+        }
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（待报价）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.TODO, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesTodo(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（待报价）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("status", Status.NOT_REPLY.value());
+        pageInfo.filter("overdue", Constant.NO);
+        pageInfo.filter("invalid", Constant.NO);
+        pageInfo.filter("vendUU", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        SearchFilter distribute = userService.distribute();
+        if (distribute != null && distribute.getDistribute() == null) {
+            return null;
+        }
+        if (distribute != null && !CollectionUtils.isEmpty(distribute.getDistribute())) {
+            filter.setDistribute(distribute.getDistribute());
+        }
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（已过期）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.END, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesEnd(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（已过期）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("overdue", Constant.YES);
+        pageInfo.filter("invalid", Constant.NO);
+        pageInfo.filter("vendUU", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        SearchFilter distribute = userService.distribute();
+        if (distribute != null && distribute.getDistribute() == null) {
+            return null;
+        }
+        if (distribute != null && !CollectionUtils.isEmpty(distribute.getDistribute())) {
+            filter.setDistribute(distribute.getDistribute());
+        }
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（已报价）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.DONE, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesDone(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（已报价）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("overdue", Constant.NO);
+        pageInfo.filter("status", Status.REPLIED.value());
+        pageInfo.filter("invalid", Constant.NO);
+        pageInfo.filter("vendUU", SystemSession.getUser().getEnterprise().getUu());
+        pageInfo.filter("decideStatus", Status.UNAUDIT.value());
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        SearchFilter distribute = userService.distribute();
+        if (distribute != null && distribute.getDistribute() == null) {
+            return null;
+        }
+        if (distribute != null && !CollectionUtils.isEmpty(distribute.getDistribute())) {
+            filter.setDistribute(distribute.getDistribute());
+        }
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（已失效）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.INVALID, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesInvalid(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（已失效）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("overdue", Constant.YES);
+        pageInfo.filter("vendUU", SystemSession.getUser().getEnterprise().getUu());
+        pageInfo.filter("invalid", Constant.YES);
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        SearchFilter distribute = userService.distribute();
+        if (distribute != null && distribute.getDistribute() == null) {
+            return null;
+        }
+        if (distribute != null && !CollectionUtils.isEmpty(distribute.getDistribute())) {
+            filter.setDistribute(distribute.getDistribute());
+        }
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（未采纳）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.REFUSED, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesRefused(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（未采纳）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("agreed", Constant.NO);
+        pageInfo.filter("status", Status.REPLIED.value());
+        pageInfo.filter("invalid", Constant.NO);
+        pageInfo.filter("vendUU", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        SearchFilter distribute = userService.distribute();
+        if (distribute != null && distribute.getDistribute() == null) {
+            return null;
+        }
+        if (distribute != null && !CollectionUtils.isEmpty(distribute.getDistribute())) {
+            filter.setDistribute(distribute.getDistribute());
+        }
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（已采纳）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.AGREED, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesAgreed(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（已采纳）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("vendUU", SystemSession.getUser().getEnterprise().getUu());
+        pageInfo.filter("agreed", Constant.YES);
+        pageInfo.filter("status", Status.REPLIED.value());
+        pageInfo.filter("invalid", Constant.NO);
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        SearchFilter distribute = userService.distribute();
+        if (distribute != null && distribute.getDistribute() == null) {
+            return null;
+        }
+        if (distribute != null && !CollectionUtils.isEmpty(distribute.getDistribute())) {
+            filter.setDistribute(distribute.getDistribute());
+        }
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（全部）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/search", method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getReceivedPurchaseInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看收到的客户询价单列表（全部）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为供应商
+        pageParams.getFilters().put("id_venduu", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = userService.distribute();
+        if (filter != null && filter.getDistribute() == null) {
+            return null;
+        }
+        if (filter != null && !CollectionUtils.isEmpty(filter.getDistribute())) {
+            List<Object> list = new ArrayList<>();
+            for (Object object : filter.getDistribute()) {
+                list.add(object);
+            }
+            pageParams.getFilters().put("id_inid", new MultiValue(list, true));
+        }
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（待报价）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.TODO, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getTodoInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看收到的客户询价单（待报价）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为供应商
+        pageParams.getFilters().put("id_venduu", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = userService.distribute();
+        if (filter != null && filter.getDistribute() == null) {
+            return null;
+        }
+        if (filter != null && !CollectionUtils.isEmpty(filter.getDistribute())) {
+            List<Object> list = new ArrayList<>();
+            for (Object object : filter.getDistribute()) {
+                list.add(object);
+            }
+            pageParams.getFilters().put("id_inid", new MultiValue(list, true));
+        }
+        pageParams.getFilters().put("id_status", Status.NOT_REPLY.value());
+        pageParams.getFilters().put("id_overdue", Constant.NO);
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（已过期）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.END, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getEndInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看收到的客户询价单（已过期）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为供应商
+        pageParams.getFilters().put("id_venduu", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = userService.distribute();
+        if (filter != null && filter.getDistribute() == null) {
+            return null;
+        }
+        if (filter != null && !CollectionUtils.isEmpty(filter.getDistribute())) {
+            List<Object> list = new ArrayList<>();
+            for (Object object : filter.getDistribute()) {
+                list.add(object);
+            }
+            pageParams.getFilters().put("id_inid", new MultiValue(list, true));
+        }
+        pageParams.getFilters().put("id_status", Status.NOT_REPLY.value());
+        pageParams.getFilters().put("id_overdue", Constant.YES);
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("id_invalid", Constant.NO);
+        pageParams.setNotEqualFilters(map);
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（已报价）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.DONE, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getDoneInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看收到的客户询价单（已报价）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为供应商
+        pageParams.getFilters().put("id_venduu", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = userService.distribute();
+        if (filter != null && filter.getDistribute() == null) {
+            return null;
+        }
+        if (filter != null && !CollectionUtils.isEmpty(filter.getDistribute())) {
+            List<Object> list = new ArrayList<>();
+            for (Object object : filter.getDistribute()) {
+                list.add(object);
+            }
+            pageParams.getFilters().put("id_inid", new MultiValue(list, true));
+        }
+        pageParams.getFilters().put("id_status", Status.REPLIED.value());
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("id_invalid", Constant.YES);
+        pageParams.setNotEqualFilters(map);
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（已失效）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.INVALID, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getInvalidInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看收到的客户询价单（已失效）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为供应商
+        pageParams.getFilters().put("id_venduu", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = userService.distribute();
+        if (filter != null && filter.getDistribute() == null) {
+            return null;
+        }
+        if (filter != null && !CollectionUtils.isEmpty(filter.getDistribute())) {
+            List<Object> list = new ArrayList<>();
+            list.addAll(filter.getDistribute());
+            pageParams.getFilters().put("id_inid", new MultiValue(list, true));
+        }
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, 1L));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        pageParams.getFilters().put("id_overdue", Constant.YES); // 已失效
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（已采纳）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.AGREED, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getAgreedInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看收到的客户询价单（已采纳）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为供应商
+        pageParams.getFilters().put("id_venduu", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = userService.distribute();
+        if (filter != null && filter.getDistribute() == null) {
+            return null;
+        }
+        if (filter != null && !CollectionUtils.isEmpty(filter.getDistribute())) {
+            List<Object> list = new ArrayList<>();
+            for (Object object : filter.getDistribute()) {
+                list.add(object);
+            }
+            pageParams.getFilters().put("id_inid", new MultiValue(list, true));
+        }
+        pageParams.getFilters().put("id_agreed", Constant.YES);
+        pageParams.getFilters().put("id_status", Status.REPLIED.value());
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("id_invalid", Constant.YES);
+        pageParams.setNotEqualFilters(map);
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为卖家，收到的采购询价（未采纳）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.REFUSED, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getRefusedInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看收到的客户询价单（未采纳）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为供应商
+        pageParams.getFilters().put("id_venduu", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = userService.distribute();
+        if (filter != null && filter.getDistribute() == null) {
+            return null;
+        }
+        if (filter != null && !CollectionUtils.isEmpty(filter.getDistribute())) {
+            List<Object> list = new ArrayList<>();
+            for (Object object : filter.getDistribute()) {
+                list.add(object);
+            }
+            pageParams.getFilters().put("id_inid", new MultiValue(list, true));
+        }
+        pageParams.getFilters().put("id_agreed", Constant.NO);
+        pageParams.getFilters().put("id_status", Status.REPLIED.value());
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为卖家，根据询价单ID查找询价单(含明细)
+     *
+     * @param id 主表id
+     * @return
+     */
+    @RequestMapping(value = "/{id}/info", method = RequestMethod.GET)
+    public List<PublicInquiryItemInfo> getReceivedPurchaseOrderItemById(@PathVariable("id") Long id) {
+        logger.log("公共询价单", "查看详情", "查看[" + id + "]的详情");
+        return pubInquiryService.findById(id);
+    }
+
+    /**
+     * 作为卖家，查看同产品的报价历史
+     *
+     */
+    @RequestMapping(value = "/items/{itemId}/history", method = RequestMethod.GET)
+    public List<PublicInquiryItemInfo> getInquiryHistoryById(@PathVariable("itemId") Long itemId) {
+        logger.log("公共询价单", "查看历史报价信息", "查看[" + itemId+ "]的历史报价");
+        return pubInquiryService.findHistoryByItemId(itemId);
+    }
+
+    /**
+     * 作为卖家，给公共询价单报价
+     *
+     * @param json 前台数据
+     * @param inquiryItemId 询价明细id
+     * @return
+     */
+    @RequestMapping(value = "/items/{inquiryItemId}/reply", method = RequestMethod.POST)
+    public ResponseEntity<String> replyInquiryItem(@RequestBody String json, @PathVariable("inquiryItemId") Long inquiryItemId, String token) {
+        PublicInquiryItem item = FlexJsonUtils.fromJson(json, PublicInquiryItem.class);
+        boolean flag = tokenService.enabled(token);
+        if (flag) {
+            item = pubInquiryService.reply(item);
+            tokenService.delete(token);
+            logger.log("公共询价单", "给单个客户公共询价明细填写价格并确认报价", item.replyDescription(), item.getInquiry().getCode(), inquiryItemId);
+        } else {
+            throw new IllegalOperatorException("页面信息已过期，请刷新重试");
+        }
+        return new ResponseEntity<String>(HttpStatus.OK);
+    }
+
+    /**
+     * 作为卖家，保存更新公共询价单
+     *
+     * @param json 前台数据
+     * @param inquiryItemId 询价明细id
+     * @return
+     */
+    @RequestMapping(value = "/items/{inquiryItemId}/save", method = RequestMethod.POST)
+    public ResponseEntity<String> saveInquiryItem(@RequestBody String json,
+                                                  @PathVariable("inquiryItemId") Long inquiryItemId, String token) {
+        PublicInquiryItem item = FlexJsonUtils.fromJson(json, PublicInquiryItem.class);
+        boolean flag = tokenService.enabled(token);
+        if (flag) {
+            item = pubInquiryService.save(item);
+            tokenService.delete(token);
+            logger.log("公共询价单", "给单个客户公共询价明细填写价格", item.replyDescription(), item.getInquiry().getCode(), inquiryItemId);
+        } else {
+            throw new IllegalOperatorException("页面信息已过期，请刷新重试");
+        }
+        return new ResponseEntity<String>(HttpStatus.OK);
+    }
+
+    /**
+     *  公共询价报价上传附件
+     *
+     * @param item 公共询价明细信息
+     * @param uploadItem 附件信息
+     * @param method 操作方法
+     * @return
+     * @throws Exception
+     */
+    @RequestMapping(value = "/addAttach", method = RequestMethod.POST)
+    public ModelMap addItemAttaches(String item, String method, FileUpload uploadItem) throws Exception {
+        PublicInquiryItem inquiryItem = FlexJsonUtils.fromJson(item, PublicInquiryItem.class);
+        if (method.equals("save")) {
+            logger.log("公共询价", "给单个客户公共询价明细填写价格，上传附件信息",  inquiryItem.replyDescription(), inquiryItem.getInquiry().getCode(), inquiryItem.getId());
+        } else if (method.equals("reply")) {
+            logger.log("公共询价", "给单个客户公共询价明细填写价格、上传附件信息并报价",  inquiryItem.replyDescription(), inquiryItem.getInquiry().getCode(), inquiryItem.getId());
+        }
+        return pubInquiryService.addAttaches(inquiryItem, method, uploadItem);
+    }
+}

src/main/java/com/uas/platform/b2b/controller/PubInquiryForPurcController.java

@@ -0,0 +1,376 @@
+package com.uas.platform.b2b.controller;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.uas.platform.b2b.model.PublicInquiryItemInfo;
+import com.uas.platform.b2b.model.SearchFilter;
+import com.uas.platform.b2b.search.SearchService;
+import com.uas.platform.b2b.service.PubInquiryService;
+import com.uas.platform.b2b.support.SystemSession;
+import com.uas.platform.b2b.support.UsageBufferedLogger;
+import com.uas.platform.b2b.temporary.model.InquiryDetailInfo;
+import com.uas.platform.core.logging.BufferedLoggerManager;
+import com.uas.platform.core.model.Constant;
+import com.uas.platform.core.model.PageInfo;
+import com.uas.platform.core.model.PageParams;
+import com.uas.platform.core.model.Status;
+import com.uas.platform.core.web.bind.RequestState;
+import com.uas.search.b2b.model.SPage;
+import com.uas.search.b2b.model.Sort;
+import com.uas.search.b2b.util.SearchConstants;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.ui.ModelMap;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * 公共询价（针对客户）
+ *
+ * Created by hejq on 2018-01-08.
+ */
+@RequestMapping("/purc/pubInquiry")
+@RestController
+public class PubInquiryForPurcController {
+
+    private final static UsageBufferedLogger logger = BufferedLoggerManager.getLogger(UsageBufferedLogger.class);
+
+    @Autowired
+    private PubInquiryService pubInquiryService;
+
+    @Autowired
+    private SearchService searchService;
+
+    /**
+     * 作为买家，发出的公共询价（全部）不搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiries(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（全部）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("inquiry.enUU", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（待报价）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.TODO, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesTodo(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（待报价）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("status", Status.NOT_REPLY.value());
+        pageInfo.filter("overdue", Constant.NO);
+        pageInfo.filter("invalid", Constant.NO);
+        pageInfo.filter("inquiry.enUU", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（已过期）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.END, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesEnd(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（已过期）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("overdue", Constant.YES);
+        pageInfo.filter("invalid", Constant.NO);
+        pageInfo.filter("inquiry.enUU", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（已报价）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.DONE, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesDone(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（已报价）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("overdue", Constant.NO);
+        pageInfo.filter("status", Status.REPLIED.value());
+        pageInfo.filter("invalid", Constant.NO);
+        pageInfo.filter("inquiry.enUU", SystemSession.getUser().getEnterprise().getUu());
+        pageInfo.filter("decideStatus", Status.UNAUDIT.value());
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（已失效）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.INVALID, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesInvalid(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（已失效）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("overdue", Constant.YES);
+        pageInfo.filter("inquiry.enUU", SystemSession.getUser().getEnterprise().getUu());
+        pageInfo.filter("invalid", Constant.YES);
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（未采纳）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.REFUSED, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesRefused(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（未采纳）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("agreed", Constant.NO);
+        pageInfo.filter("status", Status.REPLIED.value());
+        pageInfo.filter("invalid", Constant.NO);
+        pageInfo.filter("inquiry.enUU", SystemSession.getUser().getEnterprise().getUu());
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（已采纳）
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/nosearch", params = RequestState.AGREED, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getPurchaseInquiriesAgreed(PageParams params, String searchFilter) {
+        logger.log("公共询价单", "查看已转询价报价单的客户公共询价单列表（已采纳）");
+        PageInfo pageInfo = new PageInfo(params);
+        pageInfo.filter("inquiry.enUU", SystemSession.getUser().getEnterprise().getUu());
+        pageInfo.filter("agreed", Constant.YES);
+        pageInfo.filter("status", Status.REPLIED.value());
+        pageInfo.filter("invalid", Constant.NO);
+        SearchFilter filter = JSONObject.parseObject(searchFilter, SearchFilter.class);
+        return pubInquiryService.findByPageInfo(pageInfo, null, filter);
+    }
+
+
+    /**
+     * 作为买家，发出的公共询价（全部）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/search", method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getReceivedPurchaseInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看发出的已转报价的公共询价单列表（全部）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为客户
+        pageParams.getFilters().put("id_inid", SystemSession.getUser().getEnterprise().getUu());
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（待报价）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.TODO, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getTodoInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看发出的已转报价的公共询价单（待报价）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为客户
+        pageParams.getFilters().put("id_inid", SystemSession.getUser().getEnterprise().getUu());
+        pageParams.getFilters().put("id_status", Status.NOT_REPLY.value());
+        pageParams.getFilters().put("id_overdue", Constant.NO);
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（已过期）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.END, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getEndInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看发出的已转报价的公共询价单（已过期）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为客户
+        pageParams.getFilters().put("id_inid", SystemSession.getUser().getEnterprise().getUu());
+        pageParams.getFilters().put("id_status", Status.NOT_REPLY.value());
+        pageParams.getFilters().put("id_overdue", Constant.YES);
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("id_invalid", Constant.NO);
+        pageParams.setNotEqualFilters(map);
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（已报价）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.DONE, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getDoneInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看发出的已转报价的公共询价单（已报价）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为客户
+        pageParams.getFilters().put("id_inid", SystemSession.getUser().getEnterprise().getUu());
+        pageParams.getFilters().put("id_status", Status.REPLIED.value());
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("id_invalid", Constant.YES);
+        pageParams.setNotEqualFilters(map);
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（已失效）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.INVALID, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getInvalidInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看发出的已转报价的公共询价单（已失效）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为客户
+        pageParams.getFilters().put("id_inid", SystemSession.getUser().getEnterprise().getUu());
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, 1L));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        pageParams.getFilters().put("id_overdue", Constant.YES); // 已失效
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（已采纳）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.AGREED, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getAgreedInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看发出的已转报价的公共询价单（已采纳）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为客户
+        pageParams.getFilters().put("id_inid", SystemSession.getUser().getEnterprise().getUu());
+        pageParams.getFilters().put("id_agreed", Constant.YES);
+        pageParams.getFilters().put("id_status", Status.REPLIED.value());
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("id_invalid", Constant.YES);
+        pageParams.setNotEqualFilters(map);
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为买家，发出的公共询价（未采纳）- 搜索
+     *
+     * @param params 分页参数
+     * @param searchFilter 过滤条件
+     * @return
+     */
+    @RequestMapping(value = "/info/search", params = RequestState.REFUSED, method = RequestMethod.GET)
+    public SPage<PublicInquiryItemInfo> getRefusedInquiries(PageParams params, String searchFilter) {
+        logger.log("客户询价单", "搜索查看发出的已转报价的公共询价单（未采纳）");
+        JSONObject jsonObject = JSON.parseObject(searchFilter);
+        String keyword = jsonObject.getString("keyword");
+        com.uas.search.b2b.model.PageParams pageParams = searchService.convertPageParams(params, searchFilter);
+        // 当前登录企业作为客户
+        pageParams.getFilters().put("id_inid", SystemSession.getUser().getEnterprise().getUu());
+        pageParams.getFilters().put("id_agreed", Constant.NO);
+        pageParams.getFilters().put("id_status", Status.REPLIED.value());
+        List<Sort> sortList = new ArrayList<>();
+        sortList.add(new Sort("id_id", false, Sort.Type.LONG, new Long(1)));
+        pageParams.getFilters().put(SearchConstants.SORT_KEY, sortList);
+        return searchService.searchPublicInquiryItemInfoIds(keyword, pageParams);
+    }
+
+    /**
+     * 作为卖家，根据询价单ID查找询价单(含明细)
+     *
+     * @param id 主表id
+     * @return
+     */
+    @RequestMapping(value = "/{id}/info", method = RequestMethod.GET)
+    public InquiryDetailInfo getReceivedPurchaseOrderItemById(@PathVariable("id") Long id) {
+        logger.log("公共询价", "查询公共询价明细", "关联id： " + id);
+        return pubInquiryService.getInquiryDetail(id);
+    }
+
+    /**
+     * 采纳
+     *
+     * @param id 询价明细id
+     * @return
+     */
+    @RequestMapping(value = "/accept/{id}", method = RequestMethod.POST)
+    private ModelMap acceptInquiry(@PathVariable Long id) {
+        logger.log("公共询价", "采纳报价", "关联id： " + id);
+        return pubInquiryService.acceptInquiry(id);
+    }
+
+    /**
+     * 拒绝
+     *
+     * @param id 询价明细id
+     * @return
+     */
+    @RequestMapping(value = "/refuse/{id}", method = RequestMethod.POST)
+    private ModelMap refuseInquiry(@PathVariable Long id) {
+        logger.log("公共询价", "拒绝报价", "关联id： " + id);
+        return pubInquiryService.refuseInquiry(id);
+    }
+
+}

src/main/java/com/uas/platform/b2b/service/PubInquiryService.java

@@ -0,0 +1,132 @@
+package com.uas.platform.b2b.service;
+
+import com.uas.platform.b2b.erp.model.Inquiry;
+import com.uas.platform.b2b.model.FileUpload;
+import com.uas.platform.b2b.model.PublicInquiryItem;
+import com.uas.platform.b2b.model.PublicInquiryItemInfo;
+import com.uas.platform.b2b.model.SearchFilter;
+import com.uas.platform.b2b.temporary.model.InquiryDetailInfo;
+import com.uas.platform.core.model.PageInfo;
+import com.uas.search.b2b.model.SPage;
+import org.springframework.ui.ModelMap;
+
+import java.util.List;
+
+/**
+ * 公共询价接口方法
+ *
+ * Created by hejq on 2018-01-06.
+ */
+public interface PubInquiryService {
+
+    /**
+     * 将公共询价列表转成需要报价的询价单，类型是公共询价
+     *
+     * @param id 公共询价明细id
+     * @return
+     */
+    ModelMap transtoInquiry(Long id);
+
+    /**
+     * 通过分页及其他条件查询公共询价信息（不做搜索）
+     * @param pageInfo 分页信息
+     * @param keyword 搜索词
+     * @param filter 过滤条件
+     * @return
+     */
+    SPage<PublicInquiryItemInfo> findByPageInfo(PageInfo pageInfo, String keyword, SearchFilter filter);
+
+    /**
+     * 根据询价的id查询询价详情
+     *
+     * @param id 询价单id
+     * @return
+     */
+    List<PublicInquiryItemInfo> findById(Long id);
+
+    /**
+     * 通过明细id查询报价历史
+     *
+     * @param itemId 明细id
+     * @return
+     */
+    List<PublicInquiryItemInfo> findHistoryByItemId(Long itemId);
+
+    /**
+     * 对公共询价单进行报价
+     *
+     * @param item 公共询价明细信息
+     * @return
+     */
+    PublicInquiryItem reply(PublicInquiryItem item);
+
+    /**
+     * 对公共询价单进行报价信息保存
+     *
+     * @param item 公共询价明细信息
+     * @return
+     */
+    PublicInquiryItem save(PublicInquiryItem item);
+
+    /**
+     * 通过主表id查询发出的公共询价详情
+     *
+     * @param id 公共询价主表id
+     * @return
+     */
+    InquiryDetailInfo getInquiryDetail(Long id);
+
+    /**
+     * 采纳供应商报价信息
+     *
+     * @param id 明细id
+     * @return
+     */
+    ModelMap acceptInquiry(Long id);
+
+    /**
+     * 拒绝供应商报价信息
+     *
+     * @param id 明细id
+     * @return
+     */
+    ModelMap refuseInquiry(Long id);
+
+    /**
+     * 上传附件信息
+     *
+     * @param item 询价明细
+     * @param method 方法
+     * @param uploadItem 附件信息
+     * @return
+     */
+    ModelMap addAttaches(PublicInquiryItem item, String method, FileUpload uploadItem) throws Exception;
+
+    /**
+     * 获取供应商已报价未下载的单据
+     *
+     * @return
+     */
+    List<PublicInquiryItemInfo> findNotUploadReply();
+
+    /**
+     * 下载完成后更新平台询价单明细的下载状态
+     *
+     * @param split 询价单明细id
+     */
+    void onReplyUploadSuccess(String[] split);
+
+    /**
+     * 更新ERP的的采纳结果到平台
+     *
+     * @param publicInquiryItems 转换过后的报价明细
+     */
+    void onReplyDecide(List<PublicInquiryItem> publicInquiryItems);
+
+    /**
+     * 将ERP作废信息传到平台进行处理
+     *
+     * @param inquiries Inquiry信息
+     */
+    void onReplyInvalid(List<Inquiry> inquiries);
+}

src/main/java/com/uas/platform/b2b/service/impl/PubInquiryServiceImpl.java

@@ -0,0 +1,662 @@
+package com.uas.platform.b2b.service.impl;
+
+import com.uas.platform.b2b.core.util.ThreadUtils;
+import com.uas.platform.b2b.dao.*;
+import com.uas.platform.b2b.erp.model.Inquiry;
+import com.uas.platform.b2b.model.*;
+import com.uas.platform.b2b.search.SearchService;
+import com.uas.platform.b2b.service.AttachService;
+import com.uas.platform.b2b.service.ProductUsersService;
+import com.uas.platform.b2b.service.PubInquiryService;
+import com.uas.platform.b2b.service.RoleService;
+import com.uas.platform.b2b.support.SystemSession;
+import com.uas.platform.b2b.support.UsageBufferedLogger;
+import com.uas.platform.b2b.support.XingePusher;
+import com.uas.platform.b2b.temporary.model.InquiryDetailInfo;
+import com.uas.platform.b2b.temporary.model.InquiryProductInfo;
+import com.uas.platform.core.concurrent.IRunnable;
+import com.uas.platform.core.exception.IllegalOperatorException;
+import com.uas.platform.core.exception.IllegalStatusException;
+import com.uas.platform.core.logging.BufferedLoggerManager;
+import com.uas.platform.core.model.Constant;
+import com.uas.platform.core.model.PageInfo;
+import com.uas.platform.core.model.Status;
+import com.uas.platform.core.persistence.criteria.PredicateUtils;
+import com.uas.search.b2b.model.PageParams;
+import com.uas.search.b2b.model.SPage;
+import org.apache.commons.collections.CollectionUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.DataAccessException;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.ui.ModelMap;
+import org.springframework.util.StringUtils;
+
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+import java.util.*;
+
+/**
+ * 公共询价方法实现层
+ *
+ * Created by hejq on 2018-01-06.
+ */
+@Service
+public class PubInquiryServiceImpl implements PubInquiryService {
+
+    private final static UsageBufferedLogger logger = BufferedLoggerManager.getLogger(UsageBufferedLogger.class);
+
+    @Autowired
+    private RoleService roleService;
+
+    @Autowired
+    private RoleDao roleDao;
+
+    @Autowired
+    private PublicInquiryItemDao publicInquiryItemDao;
+
+    @Autowired
+    private PublicInquiryDao publicInquiryDao;
+
+    @Autowired
+    private PurcInquiryItemDao purcInquiryItemDao;
+
+    @Autowired
+    private EnterpriseDao enterpriseDao;
+
+    @Autowired
+    private VendorDao vendorDao;
+
+    @Autowired
+    private ProductDao productDao;
+
+    @Autowired
+    private PublicInquiryReplyDao publicInquiryReplyDao;
+
+    @Autowired
+    private CommonDao commonDao;
+
+    @Autowired
+    private SearchService searchService;
+
+    @Autowired
+    private PublicInquiryItemInfoDao publicInquiryItemInfoDao;
+
+    @Autowired
+    private ProductUsersService productUsersService;
+
+    @Autowired
+    private PublicInquiryInfoDao publicInquiryInfoDao;
+
+    @Autowired
+    private AttachService attachService;
+
+    @Autowired
+    private AttachDao attachDao;
+
+    /**
+     * 应用来源
+     */
+    private final String SOURCERAPP = "B2B";
+
+    /**
+     * 币别
+     */
+    private final String RMB = "RMB";
+
+    /**
+     * 询价种类
+     */
+    private final String INQUIRYKIND = "publicInquiry";
+
+    /**
+     * 将公共询价列表转成需要报价的询价单，类型是公共询价
+     *
+     * @param id
+     * @return
+     */
+    @Override
+    public ModelMap transtoInquiry(Long id) {
+        ModelMap map = new ModelMap();
+        Long enuu = SystemSession.getUser().getEnterprise().getUu();
+        Long useruu = SystemSession.getUser().getUserUU();
+        // 这里先要判断是否有询价单的操作权限，涉及到后面单据查看的问题
+        Integer count = roleService.findRoleByEnUUAndUserUU(enuu, useruu);
+        Double manCount =  roleDao.findByEnuuAndUserUU(SystemSession.getUser().getEnterprise().getUu(),SystemSession.getUser().getUserUU());
+        if(count == 0 && manCount == 0) {
+            map.put("info", "您没有询价单的操作权限，请通知管理员设置权限");
+            return map;
+        }
+        PurcInquiryItem purcInquiryItem = purcInquiryItemDao.findOne(id);
+        PurcInquiry purcInquiry = purcInquiryItem.getInquiry();
+        // 先判断客户询价单是否存在这张单据
+        PublicInquiry inquiry = publicInquiryDao.findBySourceIdAndSourceApp(purcInquiry.getId(), SOURCERAPP);
+        if (null == inquiry) {// 新增
+            // 这里设置自动添加为客户关系，并且如果当前用户非管理员要进行自动分配客户处理
+            Long custuseruu = purcInquiry.getRecorderUU();
+            if(null == custuseruu) {
+                Enterprise enterprise = enterpriseDao.findOne(purcInquiry.getEnUU());
+                custuseruu = enterprise.getEnAdminuu();
+            }
+            if(null != custuseruu) {
+                vendorDao.initVendorAndDistribute(purcInquiry.getEnUU(), custuseruu, enuu, useruu);
+                logger.log("客户关系", "添加客户", "通过公共询价（" + purcInquiry.getId() + "）转询价自动添加客户关系");
+            }
+            PublicInquiry saleInquiry = new PublicInquiry();
+            saleInquiry.setDate(new Date());
+            saleInquiry.setCode(purcInquiry.getCode());
+            saleInquiry.setEnUU(purcInquiry.getEnUU());
+            saleInquiry.setEnterprise(purcInquiry.getEnterprise());
+            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<Attach> attachs = new HashSet<Attach>();
+                for (Attach attach : purcInquiry.getAttachs()) {
+                    Attach newAttach = new Attach();
+                    newAttach.setDate(new Date());
+                    newAttach.setDescription(attach.getDescription());
+                    newAttach.setName(attach.getName());
+                    newAttach.setPath(attach.getPath());
+                    newAttach.setRelativeKey(attach.getRelativeKey());
+                    newAttach.setSize(attach.getSize());
+                    newAttach.setSourceId(attach.getSourceId());
+                    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.setProduct(product);
+                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.setSourceApp(purcInquiryItem.getSource());
+                item.setCustLap(Constant.NO);
+                item.setSendStatus((short) Status.NOT_UPLOAD.value());
+                item.setSourceId(id);
+                Set<PublicInquiryReply> replies = new HashSet<PublicInquiryReply>();
+                PublicInquiryReply reply = new PublicInquiryReply();
+                reply.setLapQty((double) 0);
+                replies.add(reply);
+                item.setReplies(replies);
+                item.setNeedquantity(purcInquiryItem.getNeedquantity());
+                item.setKind(INQUIRYKIND);
+                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(SystemSession.getUser().getEnterprise().getUu(), 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.setProduct(product);
+                        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(SystemSession.getUser().getEnterprise().getUu());
+                        item.setVendUserUU(SystemSession.getUser().getUserUU());
+                        item.setSourceApp(purcInquiryItem.getSource());
+                        item.setStatus((short) Status.NOT_REPLY.value());
+                        item.setCustLap(Constant.NO);
+                        item.setSendStatus((short) Status.NOT_UPLOAD.value());
+                        item.setSourceId(id);
+                        item.setKind(INQUIRYKIND);
+                        item.setNeedquantity(purcInquiryItem.getNeedquantity());
+                        Set<PublicInquiryReply> replies = new HashSet<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 = commonDao.queryForObject("select public$inquiryitems_seq.nextval from dual", Long.class);
+                        try {
+                            commonDao.getJdbcTemplate().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.getSourceApp(), item.getStatus(), item.getCustLap(), item.getSendStatus(),
+                                    item.getSourceId(), inquiry.getId(), inquiry.getKind());
+                        } catch (DataAccessException e) {
+                            e.printStackTrace();
+                        }
+                        item = publicInquiryItemDao.findOne(idid);
+                        //回复清单更新
+                        if(replies.size() > 0) {
+                            for (PublicInquiryReply reply1 : replies) {
+                                commonDao.getJdbcTemplate().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("success", "转客户询价单失败");
+                        }
+                    }
+                }
+            }
+
+        }
+        return map;
+    }
+
+    /**
+     * 通过分页及其他条件查询公共询价信息（不做搜索）
+     *
+     * @param pageInfo 分页信息
+     * @param keyword 搜索词
+     * @param filter 过滤条件
+     * @return
+     */
+    @Override
+    public SPage<PublicInquiryItemInfo> findByPageInfo(final PageInfo pageInfo, final String keyword, final SearchFilter filter) {
+        SPage<PublicInquiryItemInfo> items = new SPage<PublicInquiryItemInfo>();
+        Page<PublicInquiryItemInfo> inquiryitems = publicInquiryItemInfoDao
+                .findAll(new Specification<PublicInquiryItemInfo>() {
+                    public Predicate toPredicate(Root<PublicInquiryItemInfo> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
+                        if (filter != null) {
+                            if (!org.springframework.util.CollectionUtils.isEmpty(filter.getDistribute()))
+                                pageInfo.expression(PredicateUtils.in("inquiry.enUU", filter.getDistribute(), false));
+                            if (filter.getFromDate() != null)
+                                pageInfo.expression(PredicateUtils.gte("inquiry.date", new Date(filter.getFromDate()), false));
+                            if (filter.getEndDate() != null)
+                                pageInfo.expression(PredicateUtils.lte("inquiry.date", new Date(filter.getEndDate()), false));
+                        }
+                        if (StringUtils.hasText(keyword)) {
+                            List<Object> lists = new ArrayList<>();
+                            PageParams pageParams = new PageParams();
+                            ModelMap map = new ModelMap();
+                            map.put("id_venduu", SystemSession.getUser().getEnterprise().getUu());
+                            pageParams.setFilters(map);
+                            for (PublicInquiryItemInfo list : searchService.searchPublicInquiryItemInfoIds(keyword, pageParams).getContent()) {
+                                lists.add(list.getId());
+                            }
+                            pageInfo.expression(PredicateUtils.in("id", lists, false));
+                        }
+                        return query.where(pageInfo.getPredicates(root, query, builder)).getRestriction();
+                    }
+                }, pageInfo);
+        items.setContent(inquiryitems.getContent());
+        items.setPage(inquiryitems.getNumber());
+        items.setSize(inquiryitems.getSize());
+        items.setTotalElement(inquiryitems.getTotalElements());
+        items.setTotalPage(inquiryitems.getTotalPages());
+        return items;
+    }
+
+    /**
+     * 根据询价的id查询询价详情
+     *
+     * @param id 询价单id
+     * @return
+     */
+    @Override
+    public List<PublicInquiryItemInfo> findById(Long id) {
+        return publicInquiryItemInfoDao.findByVendUUAndInquiry(SystemSession.getUser().getEnterprise().getUu(), id);
+    }
+
+    /**
+     * 通过明细详情查询报价历史
+     *
+     * @param itemId 明细id
+     * @return
+     */
+    @Override
+    public List<PublicInquiryItemInfo> findHistoryByItemId(Long itemId) {
+        PublicInquiryItemInfo item = publicInquiryItemInfoDao.findOne(itemId);
+        if (item != null) {
+            final PageInfo pageInfo = new PageInfo(1, 3, 1);
+            pageInfo.filter("vendUU", SystemSession.getUser().getEnterprise().getUu());
+            pageInfo.filter("productId", item.getProductId());
+            pageInfo.filter("status", (short) Status.REPLIED.value());
+            pageInfo.sorting("inquiry.date", Sort.Direction.DESC);
+            SPage<PublicInquiryItemInfo> page = findByPageInfo(pageInfo,null,null);
+            return page.getContent();
+        }
+        return null;
+    }
+
+    /**
+     * 对公共询价单进行报价
+     *
+     * @param inquiryItem 公共询价明细信息
+     * @return
+     */
+    @Override
+    @Transactional
+    public PublicInquiryItem reply(PublicInquiryItem inquiryItem) {
+        PublicInquiryItem item = publicInquiryItemDao.findOne(inquiryItem.getId());
+        if (!item.isReplyable())
+            throw new IllegalStatusException("该询价单已经报价，不允许再次报价");
+        if ((item.getInquiry().getCheck() != null && item.getInquiry().getCheck() == Constant.YES) || (item.getAgreed() != null))
+            throw new IllegalOperatorException("报价失败，客户系统已经提交了该询价单");
+        // 判断是回复报价还是修改报价
+        Short status = inquiryItem.getStatus();
+        inquiryItem.setStatus((short) Status.REPLIED.value());
+        inquiryItem.setBackStatus((short) Status.NOT_UPLOAD.value());
+        inquiryItem.setReplySendStatus((short) Status.NOT_UPLOAD.value());
+        // 将采纳状态设置成申请状态，方便过滤
+        inquiryItem.setDecideStatus((short) Status.UNAUDIT.value());
+        // 防回复记录重复
+        checkInquiryItemReplies(inquiryItem, item);
+        Long userUU = inquiryItem.getUserUU();
+        if (userUU == null) {
+            userUU = item.getInquiry().getRecorderUU();
+        }
+        if (userUU != null && userUU != 0) {
+            // 消息推送
+            XingePusher.pushByUserUU(userUU, "询价单回复", "单号:" + item.getInquiry().getCode() + ",第" + item.getNumber() + "行", "", "");
+        }
+        PublicInquiryItem purchaseInquiryItem = publicInquiryItemDao.save(inquiryItem);
+        // 更新个人物料库信息
+        productUsersService.coverToMyProduct(purchaseInquiryItem.getProductId(), SystemSession.getUser().getEnterprise().getUu(), SystemSession.getUser().getUserUU(), "客户询价单报价");
+        return purchaseInquiryItem;
+    }
+
+    /**
+     * 对公共询价单进行报价信息保存
+     *
+     * @param item 公共询价明细信息
+     * @return
+     */
+    @Override
+    public PublicInquiryItem save(PublicInquiryItem item) {
+        return publicInquiryItemDao.save(item);
+    }
+
+    /**
+     * 校验询价单回复记录
+     *
+     * @param current 当前的报价信息
+     * @param origin 已存在的报价信息
+     */
+    private void checkInquiryItemReplies(PublicInquiryItem current, PublicInquiryItem origin) {
+        if (null != current.getReplies()) {
+            for (PublicInquiryReply reply : current.getReplies()) {
+                if (null == reply.getLapQty()) {
+                    reply.setLapQty(0D);
+                }
+                if (null != origin.getReplies()) {
+                    for (PublicInquiryReply originReply : origin.getReplies()) {
+                        // 分段数量一致的情况下，通过PublicInquiryReply.id防重复
+                        if (null != originReply.getLapQty() && originReply.getLapQty() == reply.getLapQty()) {
+                            reply.setId(originReply.getId());
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 通过主表id查询发出的公共询价详情
+     *
+     * @param id 公共询价主表id
+     * @return
+     */
+    @Override
+    public InquiryDetailInfo getInquiryDetail(Long id) {
+        PublicInquiryInfo inquiry = publicInquiryInfoDao.findOne(id);
+        InquiryDetailInfo inquiryInfo = new InquiryDetailInfo();
+        if (inquiry != null) {
+            inquiryInfo.setAttachs(inquiry.getAttachs());
+            inquiryInfo.setAuditor(inquiry.getAuditor());
+            inquiryInfo.setCheck(inquiry.getCheck());
+            inquiryInfo.setCode(inquiry.getCode());
+            inquiryInfo.setDate(inquiry.getDate());
+            inquiryInfo.setEndDate(inquiry.getEndDate());
+            inquiryInfo.setEnterprise(inquiry.getEnterprise());
+            inquiryInfo.setEnUU(inquiry.getEnUU());
+            inquiryInfo.setEnvironment(inquiry.getEnvironment());
+            inquiryInfo.setId(inquiry.getId());
+            inquiryInfo.setIsOpen(inquiry.getIsOpen());
+            inquiryInfo.setOverdue(inquiry.getOverdue());
+            inquiryInfo.setPriceType(inquiry.getPriceType());
+            inquiryInfo.setRecorder(inquiry.getRecorder());
+            inquiryInfo.setRecorderUU(inquiry.getRecorderUU());
+            inquiryInfo.setRemark(inquiry.getRemark());
+            inquiryInfo.setSourceApp(inquiry.getSourceApp());
+            inquiryInfo.setSourceId(inquiry.getSourceId());
+            inquiryInfo.setShip(inquiry.getShip());
+            inquiryInfo.setInvoice(inquiry.getInvoice());
+            inquiryInfo.setInquirytype(inquiry.getInquirytype());
+            Set<Long> ids = new HashSet<Long>();
+            List<Long> idStrings = new ArrayList<>();
+            Set<InquiryProductInfo> products = new HashSet<InquiryProductInfo>();
+            if (!CollectionUtils.isEmpty(inquiry.getInquiryItems())) {
+                for (PublicInquiryItemInfo item : inquiry.getInquiryItems()) {
+                    idStrings.add(item.getProductId());
+                    ids.addAll(idStrings);
+                }
+            }
+            if (!CollectionUtils.isEmpty(ids)) {
+                for (Long idInfo : ids) {
+                    InquiryProductInfo productInfo = new InquiryProductInfo();
+                    Set<PublicInquiryItemInfo> items = new HashSet<PublicInquiryItemInfo>();
+                    Product product = productDao.findOne(idInfo);
+                    productInfo.setBrand(product.getBrand());
+                    productInfo.setId(product.getId());
+                    productInfo.setSpec(product.getSpec());
+                    productInfo.setCode(product.getCode());
+                    productInfo.setTitle(product.getTitle());
+                    productInfo.setUnit(product.getUnit());
+                    for (PublicInquiryItemInfo item : inquiry.getInquiryItems()) {
+                        if (item.getProductId().equals(idInfo)) {
+                            items.add(item);
+                        }
+                    }
+                    productInfo.setPublicInquiryItemInfos(items);
+                    products.add(productInfo);
+                    inquiryInfo.setProducts(products);
+                }
+            }
+        }
+        return inquiryInfo;
+    }
+
+    /**
+     * 采纳供应商报价信息
+     *
+     * @param id 明细id
+     * @return
+     */
+    @Override
+    public ModelMap acceptInquiry(Long id) {
+        ModelMap map = new ModelMap();
+        PublicInquiryItem item = publicInquiryItemDao.findOne(id);
+        item.setAgreed(Constant.YES);
+        item.setStatus((short) Status.REPLIED.value());
+        item = publicInquiryItemDao.save(item);
+        if (item.getAgreed().equals(Constant.YES) && item.getStatus().equals((short) Status.REPLIED.value())) {
+            map.put("success", "采纳成功");
+        } else {
+            map.put("error", "采纳失败");
+        }
+        return map;
+    }
+
+    /**
+     * 拒绝供应商报价信息
+     *
+     * @param id 明细id
+     * @return
+     */
+    @Override
+    public ModelMap refuseInquiry(Long id) {
+        ModelMap map = new ModelMap();
+        PublicInquiryItem item = publicInquiryItemDao.findOne(id);
+        item.setAgreed(Constant.NO);
+        item.setStatus((short) Status.REPLIED.value());
+        item = publicInquiryItemDao.save(item);
+        if (item.getAgreed().equals(Constant.NO) && item.getStatus().equals((short) Status.REPLIED.value())) {
+            map.put("success", "拒绝操作成功");
+        } else {
+            map.put("error", "操作失败");
+        }
+        return map;
+    }
+
+    /**
+     * 上传附件信息
+     *
+     * @param item       询价明细
+     * @param method     方法
+     * @param uploadItem 附件信息
+     * @return
+     */
+    @Override
+    public ModelMap addAttaches(PublicInquiryItem item, String method, FileUpload uploadItem) throws Exception {
+        ModelMap map = new ModelMap();
+        if (uploadItem.getFile() == null) {
+            map.put("success", "没有附件");
+            return map;
+        }
+        Attach attach = attachService.upload(uploadItem, "PublicInquiryItemAttaches", "公共询价单报价附件");
+        if (attach == null) {
+            throw new Exception("文件太大");
+        }
+        attach = attachDao.save(attach);
+        // 避免出现无附件的情况
+        Set<Attach> attachSet = item.getAttaches() != null ? item.getAttaches() : new HashSet<Attach>();
+        attachSet.add(attach);
+        if("reply".equals(method)) {
+            item = reply(item);
+        }
+        item.setAttaches(attachSet);
+        item = publicInquiryItemDao.save(item);
+        map.put("success", true);
+        map.put("item", item);
+        return map;
+    }
+
+    /**
+     * 获取供应商已报价未下载的单据
+     *
+     * @return
+     */
+    @Override
+    public List<PublicInquiryItemInfo> findNotUploadReply() {
+        List<PublicInquiryItemInfo> items =  publicInquiryItemInfoDao.findByEnUUAndBackStatus(SystemSession.getUser().getEnterprise().getUu(),
+                (short) Status.NOT_UPLOAD.value());
+        if (!CollectionUtils.isEmpty(items)) {
+            // 防止下载过程中进行操作，这里设置一个下载中的状态
+            Set<Long> ids = new HashSet<>();
+            for (PublicInquiryItemInfo item : items) {
+                ids.add(item.getId());
+            }
+            if (ids.size() > 0) {
+                publicInquiryItemDao.updateBackStatus(ids);
+            }
+        }
+        return items;
+    }
+
+    /**
+     * 下载完成后更新平台询价单明细的下载状态
+     *
+     * @param split 询价单明细id
+     */
+    @Override
+    public void onReplyUploadSuccess(String[] split) {
+        for (String id : split) {
+            PublicInquiryItem item = publicInquiryItemDao.findOne(Long.parseLong(id));
+            if (item != null) {
+                item.setBackStatus((short) Status.DOWNLOADED.value());
+                item.setErpstatus(Constant.YES);
+                item = publicInquiryItemDao.save(item);
+                logger.log("公共询价单", "更新下载状态为已下载,关联id" + item.getId());
+            }
+        }
+    }
+
+    /**
+     * 更新ERP的的采纳结果到平台
+     *
+     * @param publicInquiryItems 转换过后的报价明细
+     */
+    @Override
+    public void onReplyDecide(List<PublicInquiryItem> publicInquiryItems) {
+        for (PublicInquiryItem inquiryItem : publicInquiryItems) {
+            publicInquiryItemDao.updateDecideStatusByID(inquiryItem.getAgreed(), inquiryItem.getDecideStatus(), inquiryItem.getId());
+        }
+    }
+
+    /**
+     * 将ERP作废信息传到平台进行处理
+     *
+     * @param inquiries Inquiry信息
+     */
+    @Override
+    public void onReplyInvalid(List<Inquiry> inquiries) {
+        final Long enuu = SystemSession.getUser().getEnterprise().getUu();
+        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();
+    }
+}