dyDeliver/conf/script/1000/init/Init_17_ProductInfo.groovy

import Ignore_ExecPageFlipper as ExecPageFlipper
import com.dderp.business.dao.ProductDao
import com.dderp.common.api.NoSqlKeysService
import com.dderp.common.datas.RedisKeys
import com.dderp.common.entity.product.*
import com.dySweetFishPlugin.redis.RedisService
import com.dySweetFishPlugin.sql.TableCodeNode
import com.dySweetFishPlugin.sql.TableIdService
import com.sweetfish.convert.json.JsonConvert
import com.sweetfish.source.PageFlipper
import org.apache.commons.lang3.StringUtils
import org.rex.RMap

import java.util.concurrent.CopyOnWriteArrayList

static ProductInfo getProductLocalInfo(long idProduct, ProductDao productDao, String dataSourceId, long supplierCode) {
    //获取主表信息
    RMap paramMap = new RMap()
    paramMap.put("id", idProduct)

    ProductInfo productMaster = productDao.selectProductInfo(paramMap, dataSourceId, supplierCode)

    //获取部件表信息
    RMap paramProductMap = new RMap()
    paramProductMap.put("idproduct", idProduct)

    List<PartInfo> partSlave = productDao.selectPartInfo(paramProductMap, dataSourceId, supplierCode)

    partSlave.each { part ->
        //获取部件一级参数信息
        RMap paramPartMap = new RMap()
        paramPartMap.put("idpartinfo", part.id)

        List<PartParameter> partParameterList = productDao.selectPartParameter(paramPartMap, dataSourceId, supplierCode)

        partParameterList.each { partParameter ->
            //获取部件二级参数
            RMap paramItemMap = new RMap()
            paramItemMap.put("idPartInfo", part.id)
            paramItemMap.put("idParameter", partParameter.idParameter)
            List<PartParameterItem> partParameterItemList = productDao.selectPartParameterItem(paramItemMap, dataSourceId, supplierCode)
            partParameter.itemList = partParameterItemList
        }

        part.parameterList = partParameterList

        //获取部件工艺信息
        List<PartWorkProcess> partWorkProcessList = productDao.selectPartWorkProcess(paramPartMap, dataSourceId, supplierCode)
        part.workProcessList = partWorkProcessList
    }

    productMaster.partInfoList = partSlave

    return productMaster
}

static def createRunnable(RedisService redisService, NoSqlKeysService keysService, TableIdService tableIdService, ProductDao productDao, JsonConvert jsonConvert, String dataSourceId, long supplierCode) {
    return {
        redisService.del(keysService.getRedisKey(RedisKeys.KEY_PRODUCT_INFO, supplierCode))
        redisService.del(keysService.getRedisKey(RedisKeys.KEY_PRODUCT_DETAIL, supplierCode))

        RMap params = new RMap()
        ExecPageFlipper.execute(300, { PageFlipper p ->
            params.put("voidFlag", -1)
            List<ProductInfo> productInfoList = productDao.selectProductInfoList(params, dataSourceId, supplierCode, p)

            if (!productInfoList.isEmpty()) {
                Map<String, String> productInfoHashMap = productInfoList.collectEntries { [String.valueOf(it.id), jsonConvert.convertTo(it)] }
                redisService.hmset(keysService.getRedisKey(RedisKeys.KEY_PRODUCT_INFO, supplierCode), productInfoHashMap)
            }

            //产品详情 下面为了速度，使用并行流，所以这里使用同步的list
            List<ProductInfo> productDetailList = new CopyOnWriteArrayList<>()
            productInfoList.each { x ->
                ProductInfo productDetail = getProductLocalInfo(x.id, productDao, dataSourceId, supplierCode)
                productDetailList.add(productDetail)

                if (StringUtils.isNotBlank(x.getBillPrefix())) {
                    if (!x.getBillPrefix().trim().equalsIgnoreCase("PB"))
                        tableIdService.addTableCodeNode(TableCodeNode.newBuilder()
                                .codeName("epPrintBill.BillCode." + x.billPrefix.trim())
                                .tableName("v_epprintbillcode")
                                .codeFieldName("billCode")
                                .codePrefix(x.billPrefix)
                                .codeYear(true)
                                .yearLength(2)
                                .codeMonth(true)
                                .codeDay(x.billCodeTimeKind == 1)
                                .codeLength((x.billCodeTimeKind == 1) ? 4 : 5)
                                .build(),
                                true,
                                dataSourceId,
                                String.valueOf(supplierCode))
                }

                if (StringUtils.isNotBlank(x.getOrderPrefix())) {
                    if (!x.getOrderPrefix().trim().equalsIgnoreCase("OB"))
                        tableIdService.addTableCodeNode(TableCodeNode.newBuilder()
                                .codeName("eoPrintOrder.OrderCode." + x.orderPrefix.trim())
                                .tableName("v_eoPrintOrderCode")
                                .codeFieldName("orderCode")
                                .codePrefix(x.orderPrefix)
                                .codeYear(true)
                                .yearLength(2)
                                .codeMonth(true)
                                .codeDay(true)
                                .codeLength(4)
                                .build(),
                                true,
                                dataSourceId,
                                String.valueOf(supplierCode))
                }
            }

            if (!productDetailList.isEmpty()) {
                Map<String, String> productHashMap = productDetailList.collectEntries { [String.valueOf(it.id), jsonConvert.convertTo(it)] }
                redisService.hmset(keysService.getRedisKey(RedisKeys.KEY_PRODUCT_DETAIL, supplierCode), productHashMap)
            }
        })
    } as Runnable
}

//groovy最后一个表达式的值为返回
createRunnable(redisService, keysService, tableIdService, productDao, jsonConvert, dataSourceId, supplierCode)