station-test-api/catch/api/service/dispose.php

<?php
namespace catchAdmin\api\service;

use catchAdmin\tag_history\model\Dormitory;

class dispose
{
    private $redis;
    private $stations="stations";
    public function __construct($redis){

        $this->redis=$redis;

    }
    
    /**
     * 校验数据 如果相同标签的上一条相同位置的信号有值（不是100），而当前数据为100（实际上是信号可能没收到）则标签信号
     * 在上一条标签信号基础上+8
     */

    public function check_data($data){
        
       
        $hashKey=$data['mac'].'station';
        $key=$data['label'];
        $old_data=$this->selectHash($hashKey,$key);
        if($data["rssi1"]==100&&!empty($old_data)){
            if($old_data["rssi1"]<100){  
                $data["rssi1"]=$old_data["rssi1"]+8;
                $data["rssi1"]= $data["rssi1"]>100 ? 100:$data["rssi1"];
            }
        }
        if($data["rssi2"]==100&&!empty($old_data)){
            if($old_data["rssi2"]<100){
                $data["rssi2"]=$old_data["rssi2"]+8;
                $data["rssi2"]= $data["rssi2"]>100 ? 100:$data["rssi2"];
            }
        }
        $this->setHash($hashKey,$key,$data);
        return $data;
    }


    //计算结果设计
    public function computeResout($data){
  
       
        debug_log("InAndOUT",'接收新数据'.json_encode($data));   
       
       $res=0;
       //进出
    

       $hashkey='res'.$data['mac'];
       $key=$data['label'];
       //存入redis的数据
       $json_list= $this->selectHash($hashkey,$key);
       //最新时间
       $time=$data['report_time'];
       //进出结果
       $inAndOut=0;
       //是否参与计算
       $calculate=true;
       //前后信号如果一致  不参与计算
       if($data['rssi1']==$data['rssi2']){
            $calculate=false;
       }
        //前后信号差值小于3不参与计算，但是时间依旧保留
       $t1s= $data['rssi1']-$data['rssi2'];
       if(abs($t1s)<3){
          debug_log("InAndOUT","差值小于3不做计算");
          $calculate=false;
       }
         //如果redis没有缓存该标签的信号则创建，如果存在则更新最新时间
       if($calculate==false){
            if(!$json_list){
              
                $arr=[
                    "a"=>[],
                    'status'=> ['time'=>null,'dirt'=>null],
                    "time"=>$time, //最新时间 
                    "in_and_out"=>0   //进出结果
                ];   
            }else{
                $json_list['time']=$time;
            }
            $this->setHash($hashkey,$key,$json_list);
            return;
       }

      //rssi1强 则前面强,否则后面强
       if($data['rssi1']<$data['rssi2']){
            $res=1;  
       }
       if($data['rssi1']>$data['rssi2']){
            $res=2;  
       }
       //没有缓存的标签的数据则创建
       if(!$json_list){
       
            $arr=[
                "a"=>[['time'=>$time,'dirt'=>$res]],
                'status'=> ['time'=>null,'dirt'=>null],
                "time"=>$time, //最新时间
                "in_and_out"=>0
            ];
            debug_log("InAndOUT","数据不存在,直接存储新数据".json_encode($arr));
            $this->setHash($hashkey,$key,$arr);
            return;
       }else{


         $resArray=['time'=>$data['report_time'],'dirt'=>$res];
         debug_log("InAndOUT","缓存的数据".json_encode($json_list));
         $s=$json_list;
         //数据列表
         $list=$s['a'];
        //进出结果
         $inAndOut=$s["in_and_out"];
        //状态
         $status=$s['status'];
         //添加数据
         array_push($list,$resArray);
         //如果缓存的数据大于5条则剔除最前面的一条
        while(count($list)>5){
                array_shift($list);
                debug_log("InAndOUT","数据超过5条,剔除一条旧数据");
        }
        debug_log("InAndOUT","当前队列数据：".json_encode($list));
         $front=0;
         $back=0;
         //缓存的信号数量超过两条则参数判定方向，在里面还是在外面
        if(count($list)>2){
            //
            debug_log("InAndOUT","当前队列超过两条可以计算前后：".count($list));
            //
                foreach($list as $item){
                    if($item['dirt']==1){   
                        $front+=1;
                    }
                    if($item['dirt']==2){
                        $back+=1;
                    }
                }
                 $res=$front>$back?1:2;
                //判断有没有方向，没有方向则确定方向  1 为外  ，2为内
            if(empty($status['dirt'])){
                $status['dirt']= $res;
                $status['time']= $resArray['time'];
                debug_log("InAndOUT","初始化状态为：".json_encode($status));

            }else{
                //如果形成初始方向，且上一次连续时间上报的数据也没有形成考勤，则判断上次最后的方向，和这次初始方向是否一致，
                //例子  如果上次最后的方向是里面强，而这次的初始方向是外面强，则给上次没有形成考勤的数据补充一个"出"这个结果
                $this->no_check_data($data['mac'],$data['label'],$status['dirt'],$time,2);
                //判断是否连贯
               $IS_OK=true;
               $res=0;
               $reverse=array_reverse($list);
               $res=$reverse[0]['dirt'];
               //判断所有的信号方向是是一个朝向强
               foreach($reverse as $aitem){
                   if($aitem['dirt']!=$res){
                      $IS_OK=false;
                   } 
               }
               //判断这个方向是否和初始确定的方向是否不一致
               //如果存储的初始方向 是1 （外面强） ，$res的方向是2 ，说明形成进去这个考勤结果
                //进行保存
                if($res!=$status['dirt']&&$IS_OK){

                            $inAndOut=$status['dirt']==1?1:2;
                           //网络推送
                            $this->network_push($data['mac'],$data['label'],$resArray['time'],$inAndOut);
                            //清除历史记录
                            $this->get_label_history(3,$data['mac'],$data['label']);
                          $status['dirt']=$res;
                          $status['time']=$time;

                }else{
                   
                    debug_log("InAndOUT","无计算结果",json_encode($status));
                }
                

            }
         }
            $arr=array(
                "a"=>$list,
                'status'=>$status,
                "time"=>$time,
                "in_and_out"=>$inAndOut   //如果有形成考勤，则in_and_out 记录存储形成考勤的方向  1是进，2是出
            );
            debug_log("InAndOUT","存入缓存中:".json_encode($arr));
            $this->setHash($hashkey,$key,$arr);
            debug_log("InAndOUT",'操作结束');
       }

    }

    /**
     * 用于记录 没有生成考勤的数据信息
     * @param $mac    基站
     * @param $lable  标签
     * @param $dir  1 外面  2 里面
     * @param $type  1 存入 2获取,3 清除
     * @param $time  时间戳
     * @return void
     */
    public function no_check_data($mac,$lable,$dir=0,$time=null,$type){
        $HASH_KEY=$mac."_no_check";
        $KEY=$lable;
        if($type==1){
            debug_log("没有生成考勤",$mac." ".$lable."初始方向：$dir.时间.$time");
            $frontMax=  $this->get_label_history(4,$mac,$lable);
            $backMax=  $this->get_label_history(5,$mac,$lable);
            $records=false;
            debug_log("没有生成考勤",$mac." ".$lable."初始方向：$dir.时间.$time.前面最小值：$frontMax.里面最小值.$backMax");
            if($dir==1){
                $records=$frontMax<65;
            }
            if($dir==2){
                $records=$backMax<65;
            }
            if($records){
                debug_log("没有生成考勤",$mac." ".$lable."初始方向：$dir.时间.$time.存入redis");
                $this->setHash( $HASH_KEY,$KEY,["time"=>$time,"dir"=>$dir]);
            }

        }
        if($type==2){
            $data= $this->selectHash($HASH_KEY,$KEY);
            if(empty($data)){
                return false;
            }else{
                debug_log("没有生成考勤","$mac.=======.$lable.新初始方向确定.$dir.原来方向确定.".$data["dir"] );

                if($data["dir"]!=$dir){
                    if($dir==1){
                        $frontMax=  $this->get_label_history(4,$mac,$lable);
                        if($frontMax<65){
                            debug_log("没有生成考勤","$mac.=======.$lable.新初始方向确定.$dir.原来方向确定.".$data["dir"]."生成进出 2");
                            $this->network_push($mac,$lable,$data["time"],2);
                        }

                    }else{
                        $backMax= $this->get_label_history(5,$mac,$lable);
                        if($backMax<65){
                            debug_log("没有生成考勤","$mac.=======.$lable.新初始方向确定.$dir.原来方向确定.".$data["dir"]."生成进出 1");
                            $this->network_push($mac,$lable,$data["time"],1);
                        }

                    }
                }
            }
        }
        if($type==3){
            $this->delHash($HASH_KEY,$KEY);
        }

    }


    //获取所有基站
    public function getStations(){
        $key=$this->stations;
        $list= $this->redis->hKeys($key);
        return $list;
    }
    //获取基站最新时间
    public function getNowStationTime($mac){
        $key=$this->stations;
        $time= $this->selectHash($key,$mac);
        if(empty($time))
        {
            return time();
        }
        return $time;
    }
    //存入基站号
    public function setStations($Stations,$time){
        $key=$this->stations;
        $this->redis->hSet($key,$Stations,$time);
    }



/**
 * 获取远程推送的数据
 *
 * @param [type] $url
 * @param [type] $data
 * @return void
 */

public function getRemoteData($data){

    $key="push_data";
    $redis=$this->redis;
    $redis->Rpush($key,json_encode($data));
    
}
/**
 * 历史标签信号
 *
 * @return void
 */
public function set_label_history($data){
    $MAC=$data["mac"];
    $key=$MAC."_label_history";
    $head=$data['label']."_head";
    $tail=$data["label"]."_tail";
    $frontMaxKey=$data['label'].'_frontMax';
    $backMaxKey=$data['label'].'_backMax';
    $frontMax=null;
    $backMax=null;
   
    //保存头部
    $head_data= $this->selectHash($key,$head);
    $tail_data=$this->selectHash($key,$tail);
    //保存朝外的信号最大值
    $frontMax=$this->selectHash($key,$frontMaxKey);
    //保存朝内的信号最大值
    $backMax=$this->selectHash($key,$backMaxKey);
    if(empty($frontMax)){
        $frontMax=$data["rssi1"];
    }else{
        $frontMax=$data["rssi1"]<$frontMax?$data["rssi1"]:$frontMax;    
    }
    if(empty($backMax)){
        $backMax=$data["rssi2"];
    }else{
        $backMax=$data["rssi2"]<$backMax?$data["rssi2"]:$backMax;    
    }
    $this->setHash($key,$frontMaxKey,$frontMax);
    $this->setHash($key,$backMaxKey,$backMax);

    if(!empty($tail_data)){
        if(($data["report_time"]-$tail_data[count($tail_data)-1]["report_time"])>6){
          $head_data=[];
          $tail_data=[];
        }
     }
     //保存头部的标签数据
    if(empty($head_data)||count($head_data)<3){
       
        $head_data=empty($head_data)?[]: $head_data;
        
        array_push($head_data,$data);
        $this->setHash($key,$head,$head_data);
    }
    //保存尾部标签数据
    
    $tail_data=empty($tail_data)?[]: $tail_data;
    array_push($tail_data,$data);
    while(count($tail_data)>3){
        array_shift($tail_data);
    }
    $this->setHash($key,$tail,$tail_data);
}
/**
 * 获取基站
 *
 * @param [type] $type  1 头部  2 尾部 3清空
 * @param [type] $mac  
 * @param [type] $label 
 * @return void
 */
public function get_label_history($type,$mac,$label){
 
    $key=$mac."_label_history";
    $head=$label."_head";
    $tail=$label."_tail";
    $frontMaxKey=$label.'_frontMax';
    $backMaxKey=$label.'_backMax';
    if($type==1){
        $head_data= $this->selectHash($key,$head);
        return $head_data;
    }
    if($type==2){
        $tail_data= $this->selectHash($key,$tail);
        return $tail_data;
    }
    if($type==3){
        debug_log("InAndOUT","清空头部和尾部历史:".$mac." ".$label);
        $this->delHash($key,$head);
        $this->delHash($key,$tail);
        $this->delHash($key,$frontMaxKey);
        $this->delHash($key, $backMaxKey);
    }
    if($type==4){
        $frontMax= $this->selectHash($key,$frontMaxKey);
        return $frontMax;
    }
    if($type==5){
        $backMax= $this->selectHash($key,$backMaxKey);
        return $backMax;
    }

}

    /**
     * @param $mac
     * @param $label
     * @param $time
     * @param $dir  1 进 ,2 出
     * @return void
     */
    public function  network_push($mac,$label,$time,$dir)
    {
        $data_array=[];
        $data_array[]=[
            "label"=>$label,
            'time'=>$time,
            'dirt'=>$dir,
        ];
        $url_data=[
            "mac"=>$mac,
            "data"=>$data_array
        ];
        debug_log("clear_label","二次生成发送给远程".json_encode($url_data));
        //远程推送时间
        $this->set_time_results($mac,$label,$time,$dir);
        //清空记录
        $this->no_check_data($mac,$label,null,null,3);
        //远程推送
        $this->getRemoteData($url_data);

    }










/**
 * 二次生成进出
 *
 * @return void
 */
public function second_create_direction($mac,$label){
    debug_log("second_dirt","==============mac:".$mac."=======label".$label."================================");
    $key=$mac."_label_history";
    $head=$label."_head";
    $tail=$label."_tail";
    $head_dir=0;
    $tail_dir=0;
    $front=0;
    $behind=0;
    $res=0;
    $time=0;
    //获取这个基站的标签的历史信号数据
   $head_data= $this->get_label_history(1,$mac,$label);
   $tail_data= $this->get_label_history(2,$mac,$label);
   
   debug_log("second_dirt","头部标签数据".json_encode($head_data));
   debug_log("second_dirt","尾部标签数据".json_encode($tail_data));
   if(empty($head_data)){
       return false; 
   }
   
   if(empty($tail_data)){
        return false; 
    }

   if(count($head_data)<3){
        return false;
   }
   //判断前几条数据的初始朝向
   foreach($head_data as $item){
        if($item["rssi1"]<$item["rssi2"]){
            $front+=1;
        }else{
            $behind+=1;
        }
   }
   
    $head_dir=$front>$behind?1:2;
    $front=0;
    $behind=0;
//判断后几条数据的初始朝向
    foreach($tail_data as $item){
        if($item["rssi1"]<$item["rssi2"]){
            $front+=1;
        }else{
            $behind+=1;
        } 
        $time=$item['report_time'];
   }
   $tail_dir=$front>$behind?1:2;
   if($tail_dir== $head_dir){
        return false;
   }
   //判断能否生成考勤 1 进 2 出
   if($head_dir==1){
        $res=1;
   }else{
        $res=2;
   }

   $frontMax= $this->get_label_history(4,$mac,$label);
   debug_log("second_dirt","标签.$label.的最朝外的最大值".$frontMax);
   //如果朝外的信号强度最强信号高于65 则不进行计算，不生成考勤
   if($frontMax>65){
       debug_log("second_dirt","标签.$label.的最朝外的最小值大于65不参与计算");
       return false;
   }

   //早上对"进寝室不做二次计算

   $start_time=strtotime(date("Y-m-d",time()));
   $end_time=$start_time+60*60*8;
   debug_log("second_dirt","判断的时间".date("Y-m-d H:i:s",$end_time));
   debug_log("second_dirt","判断的时间".date("Y-m-d H:i:s",$time));
   //当天结束之间 当天早上7点之前进寝室，不做二次计算
    if($time<$end_time&&$res==1){
        debug_log("second_dirt","当天早上7点之前进寝室，不做二次计算");
        return false;
    }
    //获取该标签上次的考勤时间和考勤结果
    $befor_res= $this->get_time_results($mac,$label,2);
  
    if(!empty($befor_res)){
        debug_log("second_dirt","间隔时间".json_encode($befor_res));
        //如果上次考勤结果和这次考勤结果方向一致，并且间隔时间小于1小时，则不生成考勤
        if($befor_res['dir']==$res){
            $interval_time=$time-$befor_res["time"];
            debug_log("second_dirt","间隔时间".$interval_time);
            debug_log("second_dirt","间隔时间第一个小时,且方向相同 不做二次计算".$interval_time);
            if($interval_time<1*60*60){
                return false;
            }
        }

    }else{
        debug_log("second_dirt","数据为空,进行生成");
    }
   
   debug_log("second_dirt","最终结果".json_encode(["dirt"=>$res,"time"=>$time]));
    return ["dirt"=>$res,"time"=>$time];

}
/**
 * Undocumented function 基站配置
 *
 * @param [type] $mac
 * @return void
 */

public function get_station_config($mac){
     
     $Key="station_config";
     $mackey=$mac;
     $data=[
        "filter_signal"=>72,//过滤信号强度
        "history_filter_signal"=>82,//历史记录过滤的信号强度
        "init_data"=>3, //需要三条数据确定初始方向
        "change_data"=>5, //需要5条数据确定变换的方向
        "timeout"=>6,//信号超时服务时间
        "second_create_res"=>[

        ]//二次根据历史记录生成配置 数组中的参数配置  start_time,end_time,dir 1 前 2后;
     ];
     $config_data=$this->selectHash($Key,$mackey);
     if(!empty($config_data)){
        foreach($data as $key=>$value){
            $data[$key]=empty($config_data[$key])?$data[$key]:$config_data[$key];
        }
     }
    return $data;

}









    /**
     * function 设置存储结果的时间
     *
     * @param [type] $mac
     * @param [type] $label
     * @param [type] $time
     * @param [type] $dir 进出结果
     * @return void
     */
    public function set_time_results($mac,$label,$time,$dir){
        $mac_key=$mac."res_time";
        $array=["time"=>$time,"dir"=>$dir];
        $this->setHash($mac_key,$label,$array);
    }
    /**
     * function 获取存储结果的时间
     *
     * @param [type] $mac
     * @param [type] $label 
     * @param [type] $type 类型
     * @return void
     */
    public function get_time_results($mac,$label,$type=1){
        $mac_key=$mac."res_time";
        $data=$this->selectHash($mac_key,$label);
        if(empty($data)){
            return false;
        }
        if($type==1){
            return $data["time"];
        }else{
            return $data;
        }
    }



    //查询key hash
    public function selectHash($hashKey,$key){
        $res= $this->redis->hGet($hashKey,$key);
        if(empty($res)){
            return false;
        }else{
            return json_decode($res,true);
        }
    }

    public function setHash($hashKey,$key,$data){
       $this->redis->hSet($hashKey,$key,json_encode($data));
      
    } 
    public function delHash($hashKey,$key){
        $this->redis->hDel($hashKey,$key);
    }




    /**
     * 解析日志
     */
    public function analysisLog(){
        $path=app()->getRootPath()."runtime/log/2023-05-28/label_log.log";
        var_dump($path);
        var_dump(is_file($path));
        $file = fopen($path, "rb");
        debug_log("in_label","开始解析标签");
        $array=[];
        $readCvs=function($file){
            while (feof($file)===false) {
                # code...
                yield fgets($file);
            }
            fclose($file);

        };  
        debug_log("in_label","解析运行中");

    foreach ($readCvs($file) as $data) {
        
        if(strstr($data,"xsj")){
           
            $arr=  explode("{",$data);
                
            $data= json_decode("{".trim($arr[1]),true);
            debug_log("in_label",$data);
            if(!in_array($data['label'],$array)&&$data["rssi1"]>$data["rssi2"]){
                array_push($array,$data['label']);
            }
         }

    }

        foreach($array as $item){
            debug_log("in_label",$item);
        }
        debug_log("in_label","标签总数".count($array));
          


    }

    








}