Merge branch 'master' of http://10.153.19.25:10101/r/ERP_override

guoyujie

2025-04-08 1e1c416c6aa6596feb333b75d882ffeede73d3c9

 north-glass-erp/src/main/resources/mapper/pp/GlassOptimize.xml

@@ -58,6 +58,116 @@
        <result property="modifyTime" column="modify time"/>
    </resultMap>

    <!--工程信息-->
    <select id="projectInfoMp">
        SELECT
            f.order_number,
            g.child_width ,
            g.child_height ,
            f.quantity ,
            d.shape ,
            op.process_cards ,
            d.product_name ,
            d.price,
            op.remark ,
            d.building_number ,
            round(((`g`.`child_width`/ 1000 + g.child_height / 1000) * 2 * `f`.`quantity`),2) as perimeter ,
            round((`g`.`area` * `f`.`quantity`),4) AS area,
            f.technology_number ,
            g.glass_child ,
            g.icon,
            op.project_name,
            d.processing_note
        FROM
            ((pp.flow_card AS f
                LEFT JOIN sd.order_detail AS d ON (((f.order_id = d.order_id) AND (f.order_number = d.order_number))))
                LEFT JOIN sd.order_glass_detail AS g ON (((f.order_id = g.order_id) AND (f.order_number = g.order_number) AND (f.technology_number = g.technology_number))))
                INNER JOIN pp.optimize_project AS op ON op.project_no = f.project_no
        WHERE
            f.project_no = #{projectNo}
        GROUP BY
            f.order_id,
            f.technology_number,
            f.order_number;
    </select>

    <!--工程信息流程卡-->
    <select id="getProcessCardMp">
        SELECT
            fc.process_id,
            fc.order_number,
            fc.quantity,
            CONCAT(fc.technology_number, '/', COUNT(fc.technology_number)) AS layer,
            so.project,
            CONCAT(sd.child_width, ' × ', sd.child_height) AS sizes
        FROM
            pp.flow_card AS fc
                INNER JOIN sd.order AS so ON fc.order_id = so.order_id
                INNER JOIN sd.order_glass_detail AS sd ON sd.order_id = so.order_id AND fc.order_id = sd.order_id
                        AND fc.order_number = sd.order_number
        WHERE
            fc.project_no = #{projectNo}
        GROUP BY
            fc.order_id,
            fc.technology_number,
            fc.order_number
    </select>

    <select id="getFlowCardList">
        SELECT *
        FROM
            pp.flow_card AS fc
        WHERE
            fc.project_no = #{projectNo}

    </select>

    <!--库存信息-->
    <select id="materialStoreMp">
        SELECT
            i.id AS id,
            i.producer AS producer,
            i.available_quantity-i.plan_quantity AS available_quantity,
            JSON_EXTRACT(s.json, '$.width') AS width,
            JSON_EXTRACT(s.json, '$.height') AS height,
            JSON_EXTRACT(s.json, '$.thickness') AS thickness,
            JSON_EXTRACT(s.json, '$.name') AS name,
            JSON_EXTRACT(s.json, '$.model') AS model
        FROM  mm.material_inventory as `i`
                    LEFT JOIN  mm.material_store  as s ON (
                    (
                        `i`.`material_code` = `s`.`id`
                        )
                    )
        WHERE
            (
                    (`s`.`type` = '原片')
                    AND (`i`.`optimize_state` = 1)
                    AND (`i`.`available_quantity`-i.plan_quantity > 0)
                    AND JSON_EXTRACT(s.json, '$.thickness') = #{thickness}
                    AND JSON_EXTRACT(s.json, '$.model') = #{model}
                )
        ORDER BY
            `i`.`available_quantity` DESC ;
    </select>


    <select id="materialStoreOptimizeUse">
        select ms.id AS id,
               ou.use_count AS processingQuantity,
               ou.width,
               ou.height,
               ou.left_trim as leftTrim,
               ou.down_trim as downTrim,
               ou.up_trim as upTrim,
               ou.right_trim as rightTrim,
               JSON_EXTRACT(ms.json, '$.thickness') AS thickness,
               JSON_EXTRACT(ms.json, '$.name') AS name,
               JSON_EXTRACT(ms.json, '$.model') AS model
        from pp.optimize_use ou
            left join mm.material_store ms on ou.raw_stock_code=ms.id where project_no=#{projectNumber} and state=1
    </select>

    <select id="selectWordOrder" resultMap="wordOrderMap">
        select
        o.order_id,
@@ -106,33 +216,96 @@
    </select>

    <select id="getFlowCardListMp">
        select fc.process_id,
               fc.technology_number,
               fcss.TotalFloors,
               COUNT(fc.order_number)                                      as TotalNumber,
               SUM(fc.quantity)                                            as quantity,
               ROUND(SUM(od.width * od.height * fc.quantity / 1000000), 2) as area,
               o.project,
               ogd.glass_child,
               od.shape

        from pp.flow_card as fc
                 left join sd.`order` as o on fc.order_id = o.order_id
                 left join sd.order_detail as od on od.order_id = fc.order_id and od.order_number = fc.order_number
                 left join sd.order_glass_detail as ogd
                           on ogd.order_id = fc.order_id and ogd.order_number = fc.order_number and
                              ogd.technology_number = fc.technology_number
                 left join (select fcs.process_id,
                                   fcs.order_number,
                                   COUNT(DISTINCT fcs.technology_number) as TotalFloors
                            from pp.flow_card as fcs
                            GROUP BY fcs.process_id, fcs.order_number) as fcss
                           on fcss.process_id = fc.process_id and fcss.order_number = fc.order_number
        where position(#{optionVal} in ogd.glass_child)
        GROUP BY fc.process_id, fc.technology_number
        ORDER BY fc.process_id, fc.technology_number
        SELECT
            fc.process_id,
            fc.technology_number,
            fcss.TotalFloors,
            COUNT( fc.order_number ) AS TotalNumber,
            SUM( fc.quantity ) AS quantity,
            ROUND( SUM( od.width * od.height * fc.quantity / 1000000 ), 2 ) AS area,
            o.project,
            ogd.glass_child,
            od.shape,
            CONCAT( JSON_UNQUOTE( JSON_EXTRACT( pd.separation, '$.thickness' )), JSON_UNQUOTE( JSON_EXTRACT( pd.separation, '$.color' )) ) AS glassType
        FROM
            pp.flow_card AS fc
                LEFT JOIN sd.`order` AS o ON fc.order_id = o.order_id
                LEFT JOIN sd.order_detail AS od ON od.order_id = fc.order_id
                AND od.order_number = fc.order_number
                LEFT JOIN sd.order_glass_detail AS ogd ON ogd.order_id = fc.order_id
                AND ogd.order_number = fc.order_number
                AND ogd.technology_number = fc.technology_number
                LEFT JOIN (
                SELECT
                    fcs.process_id,
                    fcs.order_number,
                    COUNT( DISTINCT fcs.technology_number ) AS TotalFloors
                FROM
                    pp.flow_card AS fcs
                GROUP BY
                    fcs.process_id,
                    fcs.order_number
            ) AS fcss ON fcss.process_id = fc.process_id
                AND fcss.order_number = fc.order_number
                LEFT JOIN sd.product_detail AS pd ON pd.prod_id = od.product_id
                AND pd.glass_sort = fc.technology_number
        WHERE
                CONCAT( JSON_UNQUOTE( JSON_EXTRACT( pd.separation, '$.thickness' )), JSON_UNQUOTE( JSON_EXTRACT( pd.separation, '$.color' )) )= #{optionVal}
              and ISNULL(fc.project_no) and fc.layout_status=1
        GROUP BY
            fc.process_id,
            fc.technology_number
        ORDER BY
            fc.process_id,
            fc.technology_number
    </select>

    <select id="getFlowCardListWhole">
        SELECT 流程卡号 as process_id,
               层 as technology_number,
               总层数 as TotalFloors,
               规格 as TotalNumber,
               数量 as quantity,
               形状 as shape,
               项目 as project,
               单片名称 as glass_child,
               面积 as area,
               GlassType as glassType
        FROM pp.v_optimize_process_whole where
                CONCAT( JSON_UNQUOTE( JSON_EXTRACT( GlassType, '$.thickness' )), JSON_UNQUOTE( JSON_EXTRACT( GlassType, '$.color' )) )= #{optionVal}
    </select>

    <select id="getFlowCardListNormal">
        SELECT 流程卡号 as process_id,
               层 as technology_number,
               总层数 as TotalFloors,
               规格 as TotalNumber,
               数量 as quantity,
               形状 as shape,
               项目 as project,
               单片名称 as glass_child,
               面积 as area,
               GlassType as glassType
        FROM pp.v_optimize_process_normal where
                CONCAT( JSON_UNQUOTE( JSON_EXTRACT( GlassType, '$.thickness' )), JSON_UNQUOTE( JSON_EXTRACT( GlassType, '$.color' )) )= #{optionVal}
    </select>

    <select id="getFlowCardListPatch">
        SELECT 流程卡号 as process_id,
               层 as technology_number,
               总层数 as TotalFloors,
               规格 as TotalNumber,
               数量 as quantity,
               形状 as shape,
               项目 as project,
               单片名称 as glass_child,
               面积 as area,
               GlassType as glassType
        FROM pp.v_optimize_process_patch where
                CONCAT( JSON_UNQUOTE( JSON_EXTRACT( GlassType, '$.thickness' )), JSON_UNQUOTE( JSON_EXTRACT( GlassType, '$.color' )) )= #{optionVal}
    </select>

        <!--工程管理-->
    <select id="optimizeProjectMangeMp"  resultMap="optimizeProjectMangeMap">
        select p.`id`                                AS `id`,
               p.`project_no`                        AS `Project Number`,
@@ -160,8 +333,7 @@
        from pp.optimize_project as p
                 left join pp.optimize_admin as a on p.creater = a.Id
        where (`p`.`state` > -(1))
            and `p`.`create_time` &gt; #{startSelectTime}
            and `p`.`create_time` &lt; #{endSelectTime}
            and DATE (`p`.`create_time`) BETWEEN #{startSelectTime} AND #{endSelectTime}
        <if test="optimizeProjectMange.projectNumber != null and optimizeProjectMange.projectNumber != ''">
            and p.project_no regexp #{optimizeProjectMange.projectNumber}
        </if>
@@ -177,16 +349,37 @@
        where p.project_no = #{projectNumber}
    </update>

    <!--删除工程-->
    <delete id="deleteProjectMp">
        delete from pp.optimize_project
        where project_no = #{projectNumber}
    </delete>

    <delete id="deleteOptimizeHeatDetail">
        delete from pp.optimize_heat_detail
        where project_no = #{projectNumber}
    </delete>

    <delete id="deleteOptimizeHeatLayout">
        delete from pp.optimize_heat_layout
        where project_no = #{projectNumber}
    </delete>

    <delete id="deleteOptimizeDetail">
        delete from pp.optimize_detail
        where project_no = #{projectNumber}
    </delete>

    <select id="getProjectListMp">
        SELECT
            p.id,
            p.project_no,
            p.project_no as projectNumber,
            p.project_name,
            p.glass_type,
            p.glass_thickness,
            p.type,
            p.state,
            p.glass_total,
            p.glass_total as quantity,
            p.glass_total_area,
            p.process_qty,
            p.process_cards,
@@ -207,4 +400,332 @@
            p.project_no
    </select>

    <!--模拟计算查询流程卡-->
    <select id="selectProjectComputeMp">
        SELECT
            fc.process_id,
            fc.technology_number,
            fc.project_no,
            fcss.TotalFloors,
            COUNT(fc.order_number)                                      AS TotalNumber,
            SUM(fc.quantity)                                            AS quantity,
            ROUND(SUM(od.width * od.height * fc.quantity / 1000000), 2) AS area,
            o.project,
            ogd.glass_child,
            od.shape,
            SUBSTRING(glass_child, 1, LOCATE('mm', glass_child) - 1) as thickness,
            SUBSTRING(glass_child, LOCATE('mm', glass_child) + 2) as glassType
        FROM
            pp.flow_card AS fc
                LEFT JOIN sd.`order` AS o ON fc.order_id = o.order_id
                LEFT JOIN sd.order_detail AS od ON od.order_id = fc.order_id AND od.order_number = fc.order_number
                LEFT JOIN sd.order_glass_detail AS ogd
                          ON ogd.order_id = fc.order_id AND ogd.order_number = fc.order_number AND
                             ogd.technology_number = fc.technology_number
                LEFT JOIN (
                SELECT
                    fcs.process_id,
                    fcs.order_number,
                    COUNT(DISTINCT fcs.technology_number) AS TotalFloors
                FROM
                    pp.flow_card AS fcs
                GROUP BY
                    fcs.process_id, fcs.order_number
            ) AS fcss
                          ON fcss.process_id = fc.process_id AND fcss.order_number = fc.order_number
        WHERE
            fc.project_no = #{projectNo}
        GROUP BY
            fc.process_id, fc.technology_number
        ORDER BY
            fc.process_id, fc.technology_number;
    </select>

    <select id="selectProjectCount">
        select * from pp.optimize_project where project_no=#{projectNo}
    </select>

    <!--模拟计算流程卡详情-->
    <select id="selectComputeDetailMp1">
        SELECT
            d.width AS width,
            d.height AS height,
            f.quantity AS quantity,
            d.building_number AS `Storey Number`,
            d.shape AS shape,
            round(g.area * f.quantity, 4) AS area,
            g.icon AS `Label type`
        FROM
            pp.flow_card f
                LEFT JOIN pp.optimize_project p ON f.project_no = p.project_no
                LEFT JOIN sd.order o ON f.order_id = o.order_id
                LEFT JOIN sd.order_detail d ON f.order_id = d.order_id AND f.order_number = d.order_number
                LEFT JOIN sd.order_glass_detail g ON f.order_id = g.order_id AND f.order_number = g.order_number AND f.technology_number = g.technology_number
                LEFT JOIN sd.product_detail p2 ON d.product_id = p2.prod_id AND f.technology_number = p2.glass_sort
                LEFT JOIN pp.optimize_project j ON f.project_no = j.project_no
        WHERE
            p.state IN (1, 2)
          AND f.process_id = #{processId}
    </select>


    <!--模拟计算流程卡详情2-->
    <select id="selectComputeDetailMp">
        SELECT
            d.width AS width,
            d.height AS height,
            f.quantity AS quantity,
            d.building_number AS `Storey Number`,
            d.shape AS shape,
            round(g.area * f.quantity, 4) AS area,
            g.icon AS `Label type`,
            dal.patch_status,
            g.technology_number,
            g.order_number,
            fl.layers_number,
            g.child_width,
            g.child_height,
            fl.process_id

        FROM
            pp.flow_card f
                LEFT JOIN pp.optimize_project p ON f.project_no = p.project_no
                LEFT JOIN sd.order o ON f.order_id = o.order_id
                LEFT JOIN sd.order_detail d ON f.order_id = d.order_id AND f.order_number = d.order_number
                LEFT JOIN sd.order_glass_detail g ON f.order_id = g.order_id AND f.order_number = g.order_number AND f.technology_number = g.technology_number
                LEFT JOIN sd.product_detail p2 ON d.product_id = p2.prod_id AND f.technology_number = p2.glass_sort
                LEFT JOIN pp.optimize_project j ON f.project_no = j.project_no
                LEFT JOIN pp.damage_details dal ON  dal.order_number = g.order_number AND dal.technology_number = g.technology_number and f.process_id=dal.process_id
                LEFT JOIN pp.flow_card fl ON fl.order_id = g.order_id AND fl.order_number = g.order_number AND fl.technology_number = g.technology_number
        WHERE
            p.state IN (1, 2) and
          f.process_id = #{processId}
    </select>

    <select id="getProcessCardDetailmMp">
        select fc.order_number,
               ogd.child_width,
               ogd.child_height,
               fc.quantity,
               od.building_number,IF(od.shape!=2,'普形','异形') as shape,
               ROUND(ogd.child_width*ogd.child_height*fc.quantity/1000000,2) as grossArea,
               pd.separation
        from pp.flow_card as fc
                 left join sd.order_glass_detail as ogd
                           on ogd.order_id=fc.order_id and ogd.order_number=fc.order_number
                               and ogd.technology_number=fc.technology_number
                 left join sd.order_detail as od on od.order_id=ogd.order_id and od.order_number=ogd.order_number
                 left join sd.product_detail as pd on pd.prod_id=od.product_id and pd.glass_sort=fc.technology_number
        where fc.process_id=#{processId} and fc.technology_number=#{technologyNumber}
        group by fc.process_id,fc.order_number,fc.technology_number
        order by fc.order_number,fc.technology_number
    </select>

    <select id="selectGlassTypeMp">
        SELECT
            JSON_UNQUOTE(JSON_EXTRACT(type, '$.lowE')) AS lowE,
            JSON_UNQUOTE(JSON_EXTRACT(type, '$.color')) AS color,
            JSON_UNQUOTE(JSON_EXTRACT(type, '$.thickness')) AS thickness,
            JSON_UNQUOTE(JSON_EXTRACT(type, '$.craft')) AS craft,
            JSON_UNQUOTE(JSON_EXTRACT(type, '$.position')) AS position,
    CONCAT(
        JSON_UNQUOTE(JSON_EXTRACT(type, '$.thickness')),
        JSON_UNQUOTE(JSON_EXTRACT(type, '$.color'))
    ) AS glassType
        FROM pp.v_optimize_create_process_type
        GROUP BY
            thickness,
            color
        ORDER BY
            CAST(REPLACE(JSON_UNQUOTE(JSON_EXTRACT(type, '$.thickness')), 'mm', '') AS UNSIGNED);
    </select>

    <select id="getProjectIdSv">
        SELECT IFNULL(
                       (SELECT project_no
                        FROM pp.optimize_project
                        WHERE DATE(create_time) = CURDATE()
           ORDER BY create_time DESC
           LIMIT 1), '00') AS project_no;
    </select>

    <update id="updateFlowCardProject">
        UPDATE pp.flow_card set project_no=#{projectId},layout_status=2
                             where process_id=#{processId} and technology_number=#{technologyNumber}
    </update>

    <update id="updateFlowCardProjectReturn">
        UPDATE pp.flow_card set project_no=null,layout_status=1
        where process_id=#{processId} and technology_number=#{technologyNumber}
    </update>

    <select id="getSelectArea">
        select
            ROUND(SUM(ogd.child_width*ogd.child_height*fc.quantity)/1000000,2) as grossArea
        from pp.flow_card as fc
                 left join sd.order_glass_detail as ogd
                           on ogd.order_id=fc.order_id and ogd.order_number=fc.order_number
                               and ogd.technology_number=fc.technology_number
                 left join sd.order_detail as od on od.order_id=ogd.order_id and od.order_number=ogd.order_number
                 left join sd.product_detail as pd on pd.prod_id=od.product_id and pd.glass_sort=fc.technology_number
        where fc.process_id=#{processId} and fc.technology_number=#{technologyNumber}
        group by fc.process_id,fc.technology_number
    </select>

    <insert id="addProjectMp">
        insert into pp.optimize_project (project_no, project_name, order_glass_type, order_glass_thickness,glass_type, glass_thickness,
                                         glass_total,glass_total_area,type,state,process_qty,process_cards)
        values (#{projectId}, #{projectNmae}, #{glassType}, #{glassThickness}, #{glassType}, #{glassThickness},#{sumQuantity}, #{sumArea},
                #{type},1,#{processIdCount},#{processId})
    </insert>


    <insert id="addSimulation" parameterType="map">
        <foreach collection="projectdetail.data[0].glass_details" item="glass">
            INSERT INTO pp.optimize_heat_detail (
            project_no,
            process_id,
            width,
            height,
            x_axis,
            y_axis,
            rotate_angle,
            creater,
            create_time,
            update_time,
            patch_state,
            layer,
            order_sort,
            layout_id,
            sort,
            glass_id,
            pair_width,
            pair_height,
            intRemark,
            strRemark
            ) VALUES (
            #{inputValues.project_no},
            #{glass.process_id},
            #{glass.width},
            #{glass.height},
            #{glass.x_coordinate},
            #{glass.y_coordinate},
            #{glass.angle},
            #{userName},
            NOW(),
            NOW(),
            0,
            #{glass.layers_number},
            #{glass.order_number},
            #{glass.tempering_layout_id},
            #{glass.tempering_feed_sequence},
            null,
            #{glass.width},
            #{glass.height},
            null,
            null
            );
        </foreach>
    </insert>
    <!--模拟计算结果保存-->
    <insert id="addratioResult" parameterType="map">
        <foreach collection="projectdetail.data[0].ratioResult" item="glass">
            INSERT INTO pp.optimize_heat_layout (
            project_no,
            layout_id,
            glass_qty,
            glass_area,
            layout_rate,
            creater,
            create_time,
            intRemark,
            strRemark
            ) VALUES (
            #{inputValues.project_no},
            #{glass.tempering_layout_id},
            #{glass.glass_total},
            #{glass.area},
            #{glass.ratio},
            1,
            NOW(),
            null,
            null
            );
        </foreach>
    </insert>

    <!--模拟计算工程更新-->
    <update id="addratioProjectResult" parameterType="map">
        UPDATE pp.optimize_project
        SET
            state = 10,
            chaos_pct = #{inputValues.chaos_pct},
            max_load_pct = #{inputValues.max_load_pct},
            max_area=#{inputValues.max_area},
            max_qty=#{inputValues.max_qty},
            load_width=#{inputValues.load_width},
            load_length=#{inputValues.load_length},
            x_space=#{inputValues.x_space},
            y_space=#{inputValues.y_space},
            load_rate=#{inputValues.load_rate}
        WHERE
            project_no = #{inputValues.project_no}

    </update>
<!--优化设置保存-->
    <update id="optimizeParmsSave">
        update erp_user_info.user as u
        set u.optimize_parms = #{jsonString}
    </update>

    <update id="updateOptimizeResult">
        update pp.optimize_project_file as u
        set u.content = #{jsonString}
        where  u.project_no=#{processId} and type='优化结果'
    </update>



    <select id="selectOptimizeResult">
        SELECT content as Layouts
                        FROM pp.optimize_project_file
                        WHERE  project_no=#{processId} and type='优化结果';
    </select>

    <select id="getTemperedConfiguration">
        select JSON_EXTRACT( oc.config_detail, '$.glass_thickness' ) as glass_thickness,
               JSON_EXTRACT( oc.config_detail, '$.glass_type' ) as glass_type,
               JSON_EXTRACT( oc.config_detail, '$.tempering_time' ) as tempering_time,
               JSON_EXTRACT( oc.config_detail, '$.load_width' ) as load_width,
               JSON_EXTRACT( oc.config_detail, '$.load_length' ) as load_length,
               JSON_EXTRACT( oc.config_detail, '$.x_space' ) as x_space,
               JSON_EXTRACT( oc.config_detail, '$.y_space' ) as y_space
        from pp.optimize_admin oa left join pp.optimize_config oc on oa.h_id=oc.id where name='admin'
    </select>

    <select id="getEdgeTrimming">
        select JSON_EXTRACT( oc.config_detail, '$.left_trim' ) as leftTrim,
               JSON_EXTRACT( oc.config_detail, '$.up_trim' ) as upTrim,
               JSON_EXTRACT( oc.config_detail, '$.right_trim' ) as rightTrim,
               JSON_EXTRACT( oc.config_detail, '$.down_trim' ) as downTrim,
               JSON_EXTRACT( oc.config_detail, '$.auto_fill_trim' ) as autoFillTrim,
               JSON_EXTRACT( oc.config_detail, '$.quick_trim' ) as quickTrim
        from  pp.optimize_config oc where config_type=5
    </select>

    <select id="getGrindingTrimming">
        select JSON_EXTRACT( oc.config_detail, '$.left_edge' ) as leftEdge,
               JSON_EXTRACT( oc.config_detail, '$.up_edge' ) as upEdge,
               JSON_EXTRACT( oc.config_detail, '$.right_edge' ) as rightEdge,
               JSON_EXTRACT( oc.config_detail, '$.down_edge' ) as downEdge,
               JSON_EXTRACT( oc.config_detail, '$.auto_fill_edge' ) as autoFillEdge,
               JSON_EXTRACT( oc.config_detail, '$.quick_edge' ) as quickEdge,
                JSON_EXTRACT( oc.config_detail, '$.min_auto_lenght' ) as minAutoLenght
        from  pp.optimize_config oc where config_type=4
    </select>

    <update id="updateOptimizeConfig">
        UPDATE pp.optimize_config set config_detail=#{json},create_time=now()
        where config_type=#{type}
    </update>
</mapper>