mes-sdai-server-api/application/api/controller/Index.php

<?php
namespace app\api\controller;
use app\common\controller\Api;
use think\Controller;
use think\Db;
/**
 * 达成大屏数据接口
 */
class Index extends Controller{
    protected $noNeedLogin = ['*'];
    protected $noNeedRight = ['*'];
    /**首页*/
    public function index(){$this->success('成功');}

    /**
     *当日班组报工产量【缓存】
     */
    public function GroupProductionRedis(){
        // 存缓存到 Redis
        $redis = redis();
        $redis_key = md5('GroupProductionRedis');

        // 获取当天的日期
        $todays = date('Y-m-d'); // 30天前
//        $today = date('Y-m-d'); // 当天日期

        // 自定义需要显示的生产工序顺序
        $customGroups = ['裁剪', '车缝', '手工', '大烫', '总检', '包装'];

        // 获取所有设备资料，并按自定义工序顺序过滤
        $Machine = db('设备_基本资料')
            ->field('生产工序, 设备编组')
            ->whereIn('生产工序', $customGroups)
            ->select();
        // 查询当天设备产量数据
        $res = db('设备_产量计酬')->alias('c')
            ->field('c.sczl_bh, SUM(c.数量) as 数量, c.工序名称')
//            ->where('c.Sys_rq', $today)
            ->group('c.sczl_bh')
            ->select();

        // 将产量数据转换为以设备编组为键的数组，并去除空格，方便合并
        $resIndexed = [];
        foreach ($res as $item) {
            $key = trim($item['sczl_bh']); // 去除空格
            $resIndexed[$key] = $item['数量'];
        }
        // 初始化结果数组，确保所有设备编组都有数量数据
        $mergedData = [];
        foreach ($Machine as $machine) {
            $groupName = trim($machine['设备编组']); // 去除空格
            $mergedData[] = [
                '工序名称' => $machine['生产工序'],
                '组别' => $groupName,
                '数量' => isset($resIndexed[$groupName]) ? $resIndexed[$groupName] : 0 // 更新数量
            ];
        }
        // 对 $mergedData 进行排序，先按生产工序的自定义顺序排序，再按设备编组的自然顺序排序
        usort($mergedData, function ($a, $b) use ($customGroups) {
            // 按生产工序自定义顺序排序
            $groupOrderA = array_search($a['工序名称'], $customGroups);
            $groupOrderB = array_search($b['工序名称'], $customGroups);

            if ($groupOrderA === $groupOrderB) {
                // 在同一生产工序内按设备编号自然排序
                return strnatcmp($a['组别'], $b['组别']);
            }

            return $groupOrderA - $groupOrderB;
        });
        $redis->set($redis_key, json_encode($mergedData));
        echo date("Y-m-d H:i:s").'存进去了';
        return $mergedData;
    }
    //车缝
    public function GroupMachineCFyi()
    {
        $redis = redis();
        $row = json_decode($redis->get(md5('GroupProductionRedis')), true);

        // 初始化小组名称和数量
        $categories = [];
        $dataSeries = [];

        // 遍历数据，找到所有工序名称为“车缝”的小组，且不属于“大办组”、“小芬组”、“美英组”
        foreach ($row as $data) {
            if ($data['工序名称'] === '车缝' && $data['组别'] != '大办组' && $data['组别'] != '小芬组' && $data['组别'] != '美英组') {
                $categories[] = $data['组别']; // 添加组别到分类中
                $dataSeries[$data['组别']] = $data['数量']; // 更新小组数量
            }
        }

// 构建输出数据格式
        $list = [
            'categories' => $categories,
            'series' => [
                [
                    'name' => '完成',
                    'data' => array_values($dataSeries) // 获取数量数组
                ]
            ]
        ];

        $res = [
            'status' => 0,
            'msg' => '',
            'data' => $list
        ];

        // 返回 JSON 格式的结果
        return json($res);
    }

//    板房车缝
    public function GroupMachinebfCFyi()
    {
        $redis = redis();
        $row = json_decode($redis->get(md5('GroupProductionRedis')), true);

        // 初始化小组名称和数量
        $categories = [];
        $dataSeries = [];

// 遍历数据，找到所有工序名称为“车缝”的小组，且只包含“大办组”、“小芬组”、“美英组”
        foreach ($row as $data) {
            if ($data['工序名称'] === '车缝' && in_array($data['组别'], ['大办组', '小芬组', '美英组'])) {
                $categories[] = $data['组别']; // 添加组别到分类中
                $dataSeries[$data['组别']] = $data['数量']; // 更新小组数量
            }
        }

// 构建输出数据格式
        $list = [
            'categories' => $categories,
            'series' => [
                [
                    'name' => '完成',
                    'data' => array_values($dataSeries) // 获取数量数组
                ]
            ]
        ];

        $res = [
            'status' => 0,
            'msg' => '',
            'data' => $list
        ];
        // 返回 JSON 格式的结果
        return json($res);
    }

    //裁剪
    public function GroupMachineCJyi()
    {
        $redis = redis();
        $row = json_decode($redis->get(md5('GroupProductionRedis')), true);

        // 初始化小组名称和数量
        $categories = [];
        $dataSeries = [];

        // 遍历数据，找到所有工序名称为“车缝”的小组
        foreach ($row as $data) {
            if ($data['工序名称'] !== '车缝') {
                $categories[] = $data['组别']; // 添加组别到分类中
                $dataSeries[$data['组别']] = $data['数量']; // 更新小组数量
            }
        }

        // 构建输出数据格式
        $list = [
            'categories' => $categories,
            'series' => [
                [
                    'name' => '完成',
                    'data' => array_values($dataSeries) // 获取数量数组
                ]
            ]
        ];

        $res = [
            'status' => 0,
            'msg' => '',
            'data' => $list
        ];

        // 返回 JSON 格式的结果
        return json($res);
    }



    //手工
    public function GroupMachineSGyi()
    {
        $redis = redis();
        $row = json_decode($redis->get(md5('GroupProductionRedis')), true);

        // 初始化小组名称和数量
        $categories = [];
        $dataSeries = [];

        // 遍历数据，找到所有工序名称为“车缝”的小组
        foreach ($row as $data) {
            if ($data['工序名称'] === '手工') {
                $categories[] = $data['组别']; // 添加组别到分类中
                $dataSeries[$data['组别']] = $data['数量']; // 更新小组数量
            }
        }

        // 构建输出数据格式
        $list = [
            'categories' => $categories,
            'series' => [
                [
                    'name' => '完成',
                    'data' => array_values($dataSeries) // 获取数量数组
                ]
            ]
        ];

        $res = [
            'status' => 0,
            'msg' => '',
            'data' => $list
        ];

        // 返回 JSON 格式的结果
        return json($res);
    }
    //大烫
    public function GroupMachineDTyi()
    {
        $redis = redis();
        $row = json_decode($redis->get(md5('GroupProductionRedis')), true);

        // 初始化小组名称和数量
        $categories = [];
        $dataSeries = [];

        // 遍历数据，找到所有工序名称为“车缝”的小组
        foreach ($row as $data) {
            if ($data['工序名称'] === '大烫') {
                $categories[] = $data['组别']; // 添加组别到分类中
                $dataSeries[$data['组别']] = $data['数量']; // 更新小组数量
            }
        }

        // 构建输出数据格式
        $list = [
            'categories' => $categories,
            'series' => [
                [
                    'name' => '完成',
                    'data' => array_values($dataSeries) // 获取数量数组
                ]
            ]
        ];

        $res = [
            'status' => 0,
            'msg' => '',
            'data' => $list
        ];

        // 返回 JSON 格式的结果
        return json($res);
    }
    //总检
    public function GroupMachineZJyi()
    {
        $redis = redis();
        $row = json_decode($redis->get(md5('GroupProductionRedis')), true);

        // 初始化小组名称和数量
        $categories = [];
        $dataSeries = [];

        // 遍历数据，找到所有工序名称为“车缝”的小组
        foreach ($row as $data) {
            if ($data['工序名称'] === '总检') {
                $categories[] = $data['组别']; // 添加组别到分类中
                $dataSeries[$data['组别']] = $data['数量']; // 更新小组数量
            }
        }

        // 构建输出数据格式
        $list = [
            'categories' => $categories,
            'series' => [
                [
                    'name' => '完成',
                    'data' => array_values($dataSeries) // 获取数量数组
                ]
            ]
        ];

        $res = [
            'status' => 0,
            'msg' => '',
            'data' => $list
        ];

        // 返回 JSON 格式的结果
        return json($res);
    }
    //包装
    public function GroupMachineBZyi()
    {
        $redis = redis();
        $row = json_decode($redis->get(md5('GroupProductionRedis')), true);

        // 初始化小组名称和数量
        $categories = [];
        $dataSeries = [];

        // 遍历数据，找到所有工序名称为“车缝”的小组
        foreach ($row as $data) {
            if ($data['工序名称'] === '包装') {
                $categories[] = $data['组别']; // 添加组别到分类中
                $dataSeries[$data['组别']] = $data['数量']; // 更新小组数量
            }
        }

        // 构建输出数据格式
        $list = [
            'categories' => $categories,
            'series' => [
                [
                    'name' => '完成',
                    'data' => array_values($dataSeries) // 获取数量数组
                ]
            ]
        ];

        $res = [
            'status' => 0,
            'msg' => '',
            'data' => $list
        ];

        // 返回 JSON 格式的结果
        return json($res);
    }



    /**
     * 在产订单工序完工详情【缓存】
     */
    public function getJhzByRedis(){
        //存缓存Redis
        $redis = redis();
        $redis_key = md5('getJhzByRedis');
// 定义固定工序名称
        $processNames = ['裁剪', '车缝', '手工', '大烫', '总检', '包装'];
        $startTime = date('Y-m-d', strtotime('-30 days'));
        $endTime = date('Y-m-d');
        $where['c.Sys_rq'] = ['between', [$startTime, $endTime]];
        $where['j.出库日期'] = ['<>', 'NULL'];
        $where['c.mod_rq'] = null;

// 第一个查询：获取完工数量
        $list = \db('工单_基本资料')->alias('j')
            ->join('设备_产量计酬 c', 'j.订单编号 = c.订单编号', 'LEFT')
            ->field('c.订单编号, j.工单入仓数量, j.客户编号, j.生产款号, j.款式, c.工序名称, sum(c.数量) as 完工数量, j.gd_statu as 订单状态')
            ->where($where)
            ->group('c.订单编号, c.工序名称')
            ->having('完工数量 > 0')
            ->select();

// 第二个查询：获取制单数
        $yjwhere['y.Mod_rq'] = null;
        $yjlist = \db('工单_基本资料')->alias('j')
            ->join('工单_印件资料 y', 'j.订单编号 = y.订单编号', 'LEFT')
            ->field('y.订单编号, SUM(y.zdtotal) as 制单数')
            ->where($yjwhere)
            ->group('y.订单编号')
            ->select();

// 将制单数结果转换为以订单编号为键的数组，方便后续合并
        $yjlistIndexed = [];
        foreach ($yjlist as $yj) {
            $yjlistIndexed[$yj['订单编号']] = $yj['制单数'];
        }

// 合并数据
        $mergedData = [];
        foreach ($list as $order) {
            $orderId = $order['订单编号'];
            // 初始化订单数据，如果还未存在
            if (!isset($mergedData[$orderId])) {
                // 获取制单数和已完工数量
                $zdTotal = $yjlistIndexed[$orderId] ?? 0;   // 制单数
                $completedTotal = $order['工单入仓数量'];    // 已完工数量

                // 计算完成百分比
                $completionPercentage = $zdTotal > 0 ? round(($completedTotal / $zdTotal) * 100, 2) . '%' : '0%';

                // 初始化订单数据
                $mergedData[$orderId] = [
                    '订单编号' => $orderId,
                    '客户编号' => $order['客户编号'],
                    '生产款号' => $order['生产款号'],
                    '款式' => $order['款式'],
                    '订单状态' => $order['订单状态'],
                    '已完工数量' => $completedTotal,
                    '制单数' => $zdTotal,
                    '完成百分比' => $completionPercentage, // 新增字段：完成百分比
                ];

                // 初始化所有工序的完工数量为空
                foreach ($processNames as $process) {
                    $mergedData[$orderId][$process] = '';
                }
            }
            // 更新对应的工序名称和完工数量
            if (in_array($order['工序名称'], $processNames)) {
                $mergedData[$orderId][$order['工序名称']] = $order['完工数量'];
            }
        }

// 转换合并后的数组格式
        $result = array_values($mergedData);
        $redis->set($redis_key, json_encode($result));
        echo date("Y-m-d H:i:s").'存进去了';
        return $result;
    }

    /**
     * 在产订单工序完工详情【接口】
     */
    public function getJhzBy(){
        $redis = redis();
        $row = json_decode($redis->get(md5('getJhzByRedis')), true);

        // 列定义
        $result['columns'] = [
            ['name' => '订单编号', 'id' => 'ddbh', 'width' => '7%', 'autoWrap' => "true", 'textAlign' => 'left'],
            ['name' => '客户编号', 'id' => 'khbh', 'width' => '6%', 'textAlign' => 'left'],
            ['name' => '生产款号', 'id' => 'sckh', 'width' => '6%',  'textAlign' => 'left'],
            ['name' => '款式', 'id' => 'ks', 'width' => '5%',  'textAlign' => 'left'],
            ['name' => '订单状态', 'id' => 'ddzt', 'width' => '6%', 'autoWrap' => "true", 'textAlign' => 'left'],
            ['name' => '裁剪已完成', 'id' => 'cj', 'width' => '7%', 'autoWrap' => "true", 'textAlign' => 'left'],
            ['name' => '车缝已完成', 'id' => 'cf', 'width' => '7%', 'autoWrap' => "true", 'textAlign' => 'left'],
            ['name' => '手工已完成', 'id' => 'sg', 'width' => '7%', 'autoWrap' => "true", 'textAlign' => 'left'],
            ['name' => '大烫已完成', 'id' => 'dt', 'width' => '7%', 'autoWrap' => "true", 'textAlign' => 'left'],
            ['name' => '总检已完成', 'id' => 'zj', 'width' => '7%', 'autoWrap' => "true", 'textAlign' => 'left'],
            ['name' => '包装已完成', 'id' => 'bz', 'width' => '7%', 'autoWrap' => "true", 'textAlign' => 'left'],
            ['name' => '已完成数量', 'id' => 'ywgsl', 'width' => '7%', 'autoWrap' => "true", 'textAlign' => 'left'],
            ['name' => '制单总数', 'id' => 'zds', 'width' => '6%', 'autoWrap' => "true", 'textAlign' => 'left'],
            ['name' => '完成百分比', 'id' => 'bfb', 'width' => '9%', 'autoWrap' => "true", 'textAlign' => 'left'],
        ];

        if ($row) {
            foreach ($row as $k => $v) {
                $result['rows'][$k]['ddbh'] = $v['订单编号'];
                $result['rows'][$k]['khbh'] = $v['客户编号'];
                $result['rows'][$k]['sckh'] = $v['生产款号'];
                $result['rows'][$k]['ks'] = $v['款式'];
                $result['rows'][$k]['ddzt'] = $v['订单状态'];

                // 工序数量字段，根据之前的定义调整字段名
                $result['rows'][$k]['cj'] = $v['裁剪'] ?? '';
                $result['rows'][$k]['cf'] = $v['车缝'] ?? '';
                $result['rows'][$k]['sg'] = $v['手工'] ?? '';
                $result['rows'][$k]['dt'] = $v['大烫'] ?? '';
                $result['rows'][$k]['zj'] = $v['总检'] ?? '';
                $result['rows'][$k]['bz'] = $v['包装'] ?? '';

                // 其他数量字段
                $result['rows'][$k]['ywgsl'] = $v['已完工数量'] ?? '';  // 示例字段，需确保与数据一致
                $result['rows'][$k]['zds'] = $v['制单数'] ?? '';       // 对应制单数
                $result['rows'][$k]['bfb'] = $v['完成百分比'] ?? '';       // 对应制单数
            }
        } else {
            // 如果没有数据，初始化空行
            $result['rows'][0] = [
                'ddbh' => '', 'khbh' => '', 'sckh' => '', 'ks' => '', 'ddzt' => '',
                'cj' => '', 'cf' => '', 'sg' => '', 'dt' => '', 'zj' => '', 'bz' => '',
                'ywgsl' => '', 'zds' => ''
            ];
        }
//        echo "<pre>";print_r($result);echo "<pre>";die;
        $res['status'] = 0;
        $res['msg'] = '';
        $res['data'] = $result;
        return json($res);
    }


    /**
     *已制单样衣未审、已审核待生产、生产中未完成【缓存】
     */
    public function yscjDbToRedis(){
        //存缓存Redis
        $redis = redis();
        $redis_key = md5('yscjDbToRedis');
        $res = \db('工单_基本资料')
            ->where('sys_rq', '>=', date('Y-m-d', strtotime('-30 days')))
            ->select();
        $redis->set($redis_key, json_encode($res));
        echo date("Y-m-d H:i:s").'存进去了';
        return $res;
    }

    /**
     *已制单样衣未审【接口】
     * 订单已下单 未审核数量
     */
    public function yhcjDbToRedis(){
        $redis = redis();
        // 从 Redis 中获取数据
        $row = json_decode($redis->get(md5('yscjDbToRedis')), true);
        // 初始化计数器
        $count = 0;
        // 遍历数据，统计审核日期为空、mod_rq 为空、审核状态为空的数据
        foreach ($row as $item) {
            if (empty($item['审核日期']) && empty($item['Mod_rq']) && empty($item['审核'])) {
                $count++;
            }
        }
        // 构造返回数据
        $result = [
            'name' => '已制单样衣未审',
            'value' => $count,
        ];
        // 构造最终的返回结构
        $res = [
            'status' => 0,
            'msg' => '',
            'data' => [$result],
        ];
        // 返回JSON格式的结果
        return json($res);
    }

    /**
     *已审核待生产【接口】
     */
    public function getYscjByRedis(){
        $redis = redis();
        // 从 Redis 中获取数据
        $row = json_decode($redis->get(md5('yscjDbToRedis')), true);
        // 初始化计数器
        $count = 0;
        // 遍历数据，统计审核日期为空、mod_rq 为空、审核状态为空的数据
        foreach ($row as $item) {
            if (empty($item['出库日期'])) {
                $count++;
            }
        }
        // 构造返回数据
        $result = [
            'name' => '已审核待生产',
            'value' => $count,
        ];
        // 构造最终的返回结构
        $res = [
            'status' => 0,
            'msg' => '',
            'data' => [$result],
        ];
        // 返回JSON格式的结果
        return json($res);
    }

    /**
     *生产中未完成【缓存】
     */
    public function getJtClDbByRedis(){
        //存缓存Redis
        $redis = redis();
        $redis_key = md5('getJtClDbByRedis');
        $res = \db('工单_排程班次')
            ->alias('a')
            ->join('工单_印件资料 b','b.订单编号 = a.订单编号 AND a.子订单编号 = a.子订单编号')
            ->join('设备_产量计酬 c','a.订单编号 = c.订单编号 AND a.子订单编号 = c.子订单编号','LEFT')
            ->field('a.订单编号,a.子订单编号,b.款号,b.颜色,b.船样,b.zdtotal as 制单数,SUM(c.数量) as 已完成')
            ->where('a.mod_rq',null)
            ->select();
        $redis->set($redis_key, json_encode($res));
        echo date("Y-m-d H:i:s").'存进去了';
        return $res;
    }

    /**
     *生产中未完成【接口】
     */
    public function getYhcjByRedis(){
        $redis = redis();
        // 从 Redis 中获取数据
        $row = json_decode($redis->get(md5('getJtClDbByRedis')), true);
        // 初始化计数器
        $count = 0;
        // 遍历数据，统计未完成的记录条数
        foreach ($row as $item) {
            // 假设 '制单数' 是生产总数，'已完成' 是完成的数量
            if (isset($item['制单数']) && isset($item['已完成'])) {
                // 判断未完成数量是否大于0
                if ($item['制单数'] > $item['已完成']) {
                    $count++;
                }
            }
        }
        // 构造返回数据
        $result = [
            'name' => '生产中未完成',
            'value' => $count,
        ];
        // 构造最终的返回结构
        $res = [
            'status' => 0,
            'msg' => '',
            'data' => [$result],
        ];
        // 返回JSON格式的结果
        return json($res);
    }





    public function jtClDbToRedis(){

    }

}