Terminal_process_CT/exception/exception_solver.cpp

//
// Created by zx on 2020/8/20.
//

#include "exception_solver.h"
#include "command_manager.h"
#include "communication_message.h"
#include <glog/logging.h>

Exception_solver::Exception_solver() {

}
Exception_solver::~Exception_solver() {

}

/*Error_manager Exception_solver::add_task_cancel_condition(std::string license,Process_task* task)
{
    if(m_ptask_map.find(license)==true || task== nullptr)
    {
        return Error_manager(ERROR,MINOR_ERROR,"任务标识已存在,或者标识地址为null");
    }
    m_ptask_map[license]=task;
    return SUCCESS;
}

Error_manager Exception_solver::delete_task_cancel_condition(std::string license)
{
    if(m_ptask_map.find(license)==true)
    {
        m_ptask_map.erase(license);
        return SUCCESS;
    }
    return Error_manager(ERROR,MINOR_ERROR,"任务取消标志不存在");
}*/

Error_manager Exception_solver::consume_msg(Communication_message* p_msg)
{
    if(p_msg== nullptr)
        return Error_manager(POINTER_IS_NULL,CRITICAL_ERROR,"dispatch response msg pointer is null");


    switch (p_msg->get_message_type())
    {
        case Communication_message::eProcess_manual_operation_msg:
        {
            message::Process_manual_operation_msg msg;
            if(msg.ParseFromString(p_msg->get_message_buf())==false)
            {
                LOG(ERROR)<<"  手动消息解析失败  !!!";
                break;
            }
            if(msg.has_license()==false)
            {
                LOG(ERROR)<<"  手动消息解析失败  !!!";
                break;
            }
            LOG(INFO)<<"接收到手动消息//////////////////////////  : "<<msg.license();
            m_manual_msg_map[msg.license()]=msg;
            break;
        }
        case Communication_message::eEntrance_manual_operation_msg:
        {
            message::Entrance_manual_operation_msg msg;
            if(msg.ParseFromString(p_msg->get_message_buf())==false)
            {
                LOG(ERROR)<<"  手动消息解析失败  !!!";
                break;
            }
            LOG(INFO)<<" communication 接收到手动消息  : "<<msg.GetTypeName();
            switch (msg.process_type())
            {
                case message::eStoring:
                {
                    Command_manager::get_instance_pointer()->pause_entrance(msg.terminal_id(),msg.paused());
                    break;
                }
                case message::ePicking:
                {
                    Command_manager::get_instance_pointer()->pause_export(msg.terminal_id(),msg.paused());
                    break;
                }
            }
            break;
        }

        default:break;
    }
    return SUCCESS;
}


/*
     * 等待手动消息
     */
Error_manager Exception_solver::waitfor_manual_operate_msg(Process_task* task,message::Process_manual_operation_msg& msg)
{
    //清除旧的手动操作消息
    if(m_manual_msg_map.find(task->license()))
        m_manual_msg_map.erase(task->license());
    //监控新的手动操作消息
    while(task->is_canceled()==false)
    {
        if(m_manual_msg_map.find(task->license(),msg))
        {
            if(msg.has_base_info() && msg.has_license() && msg.has_operate_type() && msg.has_step_type())
            {
                if(msg.license()==task->license()&& msg.step_type()==task->current_step_type()) {
                    LOG(INFO) << " 查询到: " << task->license()<<"  操作类型:"<<Process_operation_type_Name(msg.operate_type());
                    return SUCCESS;
                }
                else
                {
                    LOG(WARNING)<<"xxxx .. ..  非当前步骤的手动操作 车牌: "<<msg.license()<<", 操作步骤:"<<Step_type_Name(msg.step_type());
                    m_manual_msg_map.erase(task->license());
                }
            }
        }
    }
    return TASK_CANCEL;
}

/*
     * 处理故障
     */
Error_manager Exception_solver::solve_exception(Error_manager code,Process_task* task)
{
    //致命故障，系统急停，取消当前流程.
    if(code.get_error_level()==CRITICAL_ERROR)
    {
        Command_manager::get_instance_pointer()->pause_system();
        task->Cancel();
        return SUCCESS;
    }

    Error_manager code_operate;

    if(task->get_process_type()==message::eStoring)
    {
        switch (task->current_step_type())
        {
            case message::eAlloc_step :
            {

                /*switch(code.get_error_code())
                {
                    case 0:
                        //重新执行
                        repeat_task_step(task);
                        return code;
                    case 1:
                        //异常无法处理，回退
                        back_task(task);
                        return code;
                    case 2:
                        //code  = .....handle
                        //异常已经处理，且恢复
                        if(code==SUCCESS)
                        {
                            //处理成功
                            complete_task_step(task);
                        }
                        else{
                            //修复失败，回退
                            back_task(task);
                        }
                        return code;
                    case 3:
                        //取消任务
                        cancel_task(task);
                        return code;
                }*/
                //return SUCCESS;
            }
            case message::eMeasure_step :
            case message::eCompare_step :
            case message::eDispatch_step :
            {

            }
            case message::eConfirm_step :
            case message::eComplete :
            case message::eBackConfirm_step :
            case message::eBackDispatch_step :
            case message::eBack_compare_step :
            case message::eBackMeasure_step :
            case message::eBackAlloc_step :
            case message::eBackComplete :
            {
                /*Command_manager::get_instance_pointer()->pause_entrance(task->terminal_id(),true);
                LOG(ERROR)<<"关闭入口:"<<task->terminal_id()<<"   故障  !!!!!!  等待手动操作 ... ";
                message::Process_manual_operation_msg operate_msg;
                code_operate=waitfor_manual_operate_msg(task,operate_msg);
                if(code_operate!=SUCCESS)
                    return code_operate;
                switch (operate_msg.operate_type())
                {
                    //取消任务
                    case message::eManual_cancel:
                    {
                        LOG(INFO) << "手动消息 ,车牌号  : " << task->license()
                            <<"  操作类型:"<<Process_operation_type_Name(operate_msg.operate_type());
                        task->Cancel();
                        break;
                    }
                    case message::eManual_retry:{
                        LOG(INFO) << "手动消息 ,车牌号  : " << task->license()
                            <<"  操作类型:"<<Process_operation_type_Name(operate_msg.operate_type());
                        break;
                    }
                    case message::eManual_ignore:
                    {
                        LOG(INFO) << "手动消息 ,车牌号  : " << task->license()
                            <<"  操作类型:"<<Process_operation_type_Name(operate_msg.operate_type());
                        return SUCCESS;
                    }
                }
                break;*/
            }
            default:        //默认回退
            {
                back_task(task);
                return code;
            }
        }
    }

    if(task->get_process_type()==message::ePicking)
    {
        switch (task->current_step_type())
        {
            case message::eSearch_step :
            case message::eDispatch_step :
            {

            }
            case message::eWait_step :
            case message::eRelease_step :
            case message::eComplete :

            case message::eBackWait_step :
            case message::eBackDispatch_step :
            case message::eBackSearch_step :
            case message::eBackComplete :
            {
                /*Command_manager::get_instance_pointer()->pause_export(task->terminal_id(),true);
                LOG(ERROR)<<"关闭出口:"<<task->terminal_id()<<"   故障  !!!!!!  等待手动操作 ...";
                message::Process_manual_operation_msg operate_msg;
                code_operate=waitfor_manual_operate_msg(task,operate_msg);
                if(code_operate!=SUCCESS)
                    return code_operate;
                switch (operate_msg.operate_type())
                {
                    //取消任务
                    case message::eManual_cancel:
                    {
                        LOG(INFO) << "手动消息 ,车牌号  : " << task->license()
                                  <<"  操作类型:"<<Process_operation_type_Name(operate_msg.operate_type());
                        task->Cancel();
                        break;
                    }
                    case message::eManual_retry:{
                        LOG(INFO) << "手动消息 ,车牌号  : " << task->license()
                                  <<"  操作类型:"<<Process_operation_type_Name(operate_msg.operate_type());
                        break;
                    }
                    case message::eManual_ignore:
                    {
                        LOG(INFO) << "手动消息 ,车牌号  : " << task->license()
                                  <<"  操作类型:"<<Process_operation_type_Name(operate_msg.operate_type());
                        return SUCCESS;
                    }
                }
                break;*/
            }
            default:
            {
                back_task(task);
                return code;
            }
        }
    }
    return code;
}


Error_manager Exception_solver::back_task(Process_task* task)
{
    task->updata_step_statu(message::eError);
    return task->next_step();
}
Error_manager Exception_solver::repeat_task_step(Process_task* task)
{
    return SUCCESS;
}
Error_manager Exception_solver::complete_task_step(Process_task* task)
{
    task->updata_step_statu(message::eFinished);
    return task->next_step();
}
Error_manager Exception_solver::cancel_task(Process_task* task)
{
    task->Cancel();
    return SUCCESS;
}