package com.heyu.api.data.entity.system;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.lz.mybatis.plugin.annotations.AS;

import java.math.BigDecimal;
import java.util.Date;import java.util.Date;
/**
*问答配置表（问答关键字匹配表，该表中未匹配到的才会调用第三方语言模型）
* @author quyixiao
* @since 2025-03-04
*/

@Data
@TableName("system_talk_answer_config")
public class SystemTalkAnswerConfigEntity implements java.io.Serializable {
private static final long serialVersionUID = 1L;

    public final static String CLASS_NAME ="com.heyu.api.data.entity.system.SystemTalkAnswerConfigEntity:";

    public final static String all = CLASS_NAME + "*";
    public final static String id_ = CLASS_NAME + "id";                                     // 
    public final static String is_delete = CLASS_NAME + "is_delete";                        // 是否删除：0 否 1 删除
    public final static String create_time = CLASS_NAME + "create_time";                    // 创建时间
    public final static String modify_time = CLASS_NAME + "modify_time";                    // 修改时间
    public final static String user_id = CLASS_NAME + "user_id";                            // 用户id
    public final static String parent_id = CLASS_NAME + "parent_id";                        // 父类ID，本表的ID。当时扩展指令时才有（answer_typeeeeee>1000）
    public final static String ask_key = CLASS_NAME + "ask_key";                            // 问题关键字
    public final static String answer_value = CLASS_NAME + "answer_value";                  // 成功回答内容（传给box）
    public final static String answer_value_faild = CLASS_NAME + "answer_value_faild";      // 执行失败回答内容
    public final static String answer_action = CLASS_NAME + "answer_action";                // 回答时的动作(数字人的口型以外动作)
    public final static String answer_action_faild = CLASS_NAME + "answer_action_faild";    // 执行失败所对应动作
    public final static String answer_back_sound = CLASS_NAME + "answer_back_sound";        // 回答时的背景音乐（URL）
    public final static String answer_back_img = CLASS_NAME + "answer_back_img";            // 回答时的背景图片、视屏、动画（URL）
    public final static String key_order = CLASS_NAME + "key_order";                        // 关键字的排序，越小越第一个匹配上
    public final static String answer_type = CLASS_NAME + "answer_type";                    // 回答类型0：文本问答 1：iOT控制 2：天气 3：闹钟 4：U3D 5：音乐声音 6：询问时间 7：古诗、诗歌、诗（千问）20：退出聆听 99：千问回答100：固件升级 101：Box上线 200：动作后必须跟的名称词 300秋果专有名词 301：根据用户编号回答不同 302：用户选择回答：要、需要、可以、好呀、好的作为yes回答，不要，不需要，不用，不好作为no回答 500+xx：代表覆盖99以内的匹配词答复 800：全部，所有，一切忽略词 2000：需要扩展的指令 扩展后的指令需要除以该值得到answer_type值
    public final static String system_same_talk_id = CLASS_NAME + "system_same_talk_id";    // 同性词Id（同性词非语言中的同义词，而是指正反一词和同一个结果的词） 0标识中性词
    public final static String action_status = CLASS_NAME + "action_status";                // 动作状态：0 开始播放 1 暂停 2 继续 3 停止 10无此资源

    public final static String must_have_noun = CLASS_NAME + "must_have_noun";              // 是否必须含有名词，针对秋果自定义词有效即answer_type >= 300
    public final static String bean_name = CLASS_NAME + "bean_name";                        // 处理Bean名字,空使用qianWenActionCommand（动词后的量词、关键字等除外200，400）
    //
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;
    //是否删除：0 否 1 删除
    private Integer isDelete;
    //创建时间
    private Date createTime;
    //修改时间
    private Date modifyTime;
    //用户id
    private Long userId;
    //父类ID，本表的ID。当时扩展指令时才有（answer_typeeeeee>1000）
    private Long parentId;
    //问题关键字
    private String askKey;
    //成功回答内容（传给box）
    private String answerValue;
    //执行失败回答内容
    private String answerValueFaild;
    //回答时的动作(数字人的口型以外动作)
    private String answerAction;
    //执行失败所对应动作
    private String answerActionFaild;
    //回答时的背景音乐（URL）
    private String answerBackSound;
    //回答时的背景图片、视屏、动画（URL）
    private String answerBackImg;
    //关键字的排序，越小越第一个匹配上
    private Long keyOrder;
    //回答类型0：文本问答 1：iOT控制 2：天气 3：闹钟 4：U3D 5：音乐声音 6：询问时间 7：古诗、诗歌、诗（千问）20：退出聆听 99：千问回答100：固件升级 101：Box上线 200：动作后必须跟的名称词 300秋果专有名词 301：根据用户编号回答不同 302：用户选择回答：要、需要、可以、好呀、好的作为yes回答，不要，不需要，不用，不好作为no回答 500+xx：代表覆盖99以内的匹配词答复 800：全部，所有，一切忽略词 2000：需要扩展的指令 扩展后的指令需要除以该值得到answer_type值
    private Integer answerType;
    //同性词Id（同性词非语言中的同义词，而是指正反一词和同一个结果的词） 0标识中性词
    private Long systemSameTalkId;
    //动作状态：0 开始播放 1 暂停 2 继续 3 停止 10无此资源

    private Integer actionStatus;
    //是否必须含有名词，针对秋果自定义词有效即answer_type >= 300
    private Integer mustHaveNoun;
    //处理Bean名字,空使用qianWenActionCommand（动词后的量词、关键字等除外200，400）
    private String beanName;
    /**
     *  
     * @return
     */
    public Long getId() {
        return id;
    }
    /**
     *  
     * @param id
     */
    public void setId(Long id) {
        this.id = id;
    }

    /**
     * 是否删除：0 否 1 删除 
     * @return
     */
    public Integer getIsDelete() {
        return isDelete;
    }
    /**
     * 是否删除：0 否 1 删除 
     * @param isDelete
     */
    public void setIsDelete(Integer isDelete) {
        this.isDelete = isDelete;
    }

    /**
     * 创建时间 
     * @return
     */
    public Date getCreateTime() {
        return createTime;
    }
    /**
     * 创建时间 
     * @param createTime
     */
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    /**
     * 修改时间 
     * @return
     */
    public Date getModifyTime() {
        return modifyTime;
    }
    /**
     * 修改时间 
     * @param modifyTime
     */
    public void setModifyTime(Date modifyTime) {
        this.modifyTime = modifyTime;
    }

    /**
     * 用户id 
     * @return
     */
    public Long getUserId() {
        return userId;
    }
    /**
     * 用户id 
     * @param userId
     */
    public void setUserId(Long userId) {
        this.userId = userId;
    }

    /**
     * 父类ID，本表的ID。当时扩展指令时才有（answer_typeeeeee>1000） 
     * @return
     */
    public Long getParentId() {
        return parentId;
    }
    /**
     * 父类ID，本表的ID。当时扩展指令时才有（answer_typeeeeee>1000） 
     * @param parentId
     */
    public void setParentId(Long parentId) {
        this.parentId = parentId;
    }

    /**
     * 问题关键字 
     * @return
     */
    public String getAskKey() {
        return askKey;
    }
    /**
     * 问题关键字 
     * @param askKey
     */
    public void setAskKey(String askKey) {
        this.askKey = askKey;
    }

    /**
     * 成功回答内容（传给box） 
     * @return
     */
    public String getAnswerValue() {
        return answerValue;
    }
    /**
     * 成功回答内容（传给box） 
     * @param answerValue
     */
    public void setAnswerValue(String answerValue) {
        this.answerValue = answerValue;
    }

    /**
     * 执行失败回答内容 
     * @return
     */
    public String getAnswerValueFaild() {
        return answerValueFaild;
    }
    /**
     * 执行失败回答内容 
     * @param answerValueFaild
     */
    public void setAnswerValueFaild(String answerValueFaild) {
        this.answerValueFaild = answerValueFaild;
    }

    /**
     * 回答时的动作(数字人的口型以外动作) 
     * @return
     */
    public String getAnswerAction() {
        return answerAction;
    }
    /**
     * 回答时的动作(数字人的口型以外动作) 
     * @param answerAction
     */
    public void setAnswerAction(String answerAction) {
        this.answerAction = answerAction;
    }

    /**
     * 执行失败所对应动作 
     * @return
     */
    public String getAnswerActionFaild() {
        return answerActionFaild;
    }
    /**
     * 执行失败所对应动作 
     * @param answerActionFaild
     */
    public void setAnswerActionFaild(String answerActionFaild) {
        this.answerActionFaild = answerActionFaild;
    }

    /**
     * 回答时的背景音乐（URL） 
     * @return
     */
    public String getAnswerBackSound() {
        return answerBackSound;
    }
    /**
     * 回答时的背景音乐（URL） 
     * @param answerBackSound
     */
    public void setAnswerBackSound(String answerBackSound) {
        this.answerBackSound = answerBackSound;
    }

    /**
     * 回答时的背景图片、视屏、动画（URL） 
     * @return
     */
    public String getAnswerBackImg() {
        return answerBackImg;
    }
    /**
     * 回答时的背景图片、视屏、动画（URL） 
     * @param answerBackImg
     */
    public void setAnswerBackImg(String answerBackImg) {
        this.answerBackImg = answerBackImg;
    }

    /**
     * 关键字的排序，越小越第一个匹配上 
     * @return
     */
    public Long getKeyOrder() {
        return keyOrder;
    }
    /**
     * 关键字的排序，越小越第一个匹配上 
     * @param keyOrder
     */
    public void setKeyOrder(Long keyOrder) {
        this.keyOrder = keyOrder;
    }

    /**
     * 回答类型0：文本问答 1：iOT控制 2：天气 3：闹钟 4：U3D 5：音乐声音 6：询问时间 7：古诗、诗歌、诗（千问）20：退出聆听 99：千问回答100：固件升级 101：Box上线 200：动作后必须跟的名称词 300秋果专有名词 301：根据用户编号回答不同 302：用户选择回答：要、需要、可以、好呀、好的作为yes回答，不要，不需要，不用，不好作为no回答 500+xx：代表覆盖99以内的匹配词答复 800：全部，所有，一切忽略词 2000：需要扩展的指令 扩展后的指令需要除以该值得到answer_type值 
     * @return
     */
    public Integer getAnswerType() {
        return answerType;
    }
    /**
     * 回答类型0：文本问答 1：iOT控制 2：天气 3：闹钟 4：U3D 5：音乐声音 6：询问时间 7：古诗、诗歌、诗（千问）20：退出聆听 99：千问回答100：固件升级 101：Box上线 200：动作后必须跟的名称词 300秋果专有名词 301：根据用户编号回答不同 302：用户选择回答：要、需要、可以、好呀、好的作为yes回答，不要，不需要，不用，不好作为no回答 500+xx：代表覆盖99以内的匹配词答复 800：全部，所有，一切忽略词 2000：需要扩展的指令 扩展后的指令需要除以该值得到answer_type值 
     * @param answerType
     */
    public void setAnswerType(Integer answerType) {
        this.answerType = answerType;
    }

    /**
     * 同性词Id（同性词非语言中的同义词，而是指正反一词和同一个结果的词） 0标识中性词 
     * @return
     */
    public Long getSystemSameTalkId() {
        return systemSameTalkId;
    }
    /**
     * 同性词Id（同性词非语言中的同义词，而是指正反一词和同一个结果的词） 0标识中性词 
     * @param systemSameTalkId
     */
    public void setSystemSameTalkId(Long systemSameTalkId) {
        this.systemSameTalkId = systemSameTalkId;
    }

    /**
     * 动作状态：0 开始播放 1 暂停 2 继续 3 停止 10无此资源
 
     * @return
     */
    public Integer getActionStatus() {
        return actionStatus;
    }
    /**
     * 动作状态：0 开始播放 1 暂停 2 继续 3 停止 10无此资源
 
     * @param actionStatus
     */
    public void setActionStatus(Integer actionStatus) {
        this.actionStatus = actionStatus;
    }

    /**
     * 是否必须含有名词，针对秋果自定义词有效即answer_type >= 300 
     * @return
     */
    public Integer getMustHaveNoun() {
        return mustHaveNoun;
    }
    /**
     * 是否必须含有名词，针对秋果自定义词有效即answer_type >= 300 
     * @param mustHaveNoun
     */
    public void setMustHaveNoun(Integer mustHaveNoun) {
        this.mustHaveNoun = mustHaveNoun;
    }

    /**
     * 处理Bean名字,空使用qianWenActionCommand（动词后的量词、关键字等除外200，400） 
     * @return
     */
    public String getBeanName() {
        return beanName;
    }
    /**
     * 处理Bean名字,空使用qianWenActionCommand（动词后的量词、关键字等除外200，400） 
     * @param beanName
     */
    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }

    @Override
    public String toString() {
        return "SystemTalkAnswerConfigEntity{" +
                ",id=" + id +
                ",isDelete=" + isDelete +
                ",createTime=" + createTime +
                ",modifyTime=" + modifyTime +
                ",userId=" + userId +
                ",parentId=" + parentId +
                ",askKey=" + askKey +
                ",answerValue=" + answerValue +
                ",answerValueFaild=" + answerValueFaild +
                ",answerAction=" + answerAction +
                ",answerActionFaild=" + answerActionFaild +
                ",answerBackSound=" + answerBackSound +
                ",answerBackImg=" + answerBackImg +
                ",keyOrder=" + keyOrder +
                ",answerType=" + answerType +
                ",systemSameTalkId=" + systemSameTalkId +
                ",actionStatus=" + actionStatus +
                ",mustHaveNoun=" + mustHaveNoun +
                ",beanName=" + beanName +
                "}";
    }
}