package com.sa.ibiz.demo.demo.domain;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonProperty.Access;
import lombok.Data;
import org.springframework.beans.BeanUtils;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.cglib.beans.BeanGenerator;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.FieldFill;
import java.util.Map;
import java.util.HashMap;
import org.springframework.util.StringUtils;
import com.sa.ibiz.demo.ibizutil.security.AuthenticationUser;
import java.util.Date;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;
import java.util.UUID;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import org.springframework.cglib.beans.BeanCopier;
import com.sa.ibiz.demo.ibizutil.annotation.Dict;
import com.sa.ibiz.demo.ibizutil.domain.EntityBase;
import java.io.Serializable;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import java.math.BigInteger;
import com.sa.ibiz.demo.ibizutil.enums.FillMode;
import com.sa.ibiz.demo.ibizutil.enums.PredefinedType;
import com.sa.ibiz.demo.ibizutil.annotation.PreField;
import com.alibaba.fastjson.annotation.JSONField;

import com.sa.ibiz.demo.demo.domain.DataEntity;
import com.sa.ibiz.demo.demo.domain.OrgSector;
import com.sa.ibiz.demo.demo.domain.Org;

/**
 * 实体[UserRoleData] 数据对象
 */
@TableName(value = "T_SRFUSERROLEDATA",resultMap = "UserRoleDataResultMap")
@JsonIgnoreProperties(ignoreUnknown = true)
@Data
public class UserRoleData extends EntityBase implements Serializable{

    @JSONField(serialize = false)
    @JsonIgnore
    @TableField(exist = false)//关系主表数据
    private DataEntity de;
    @JSONField(serialize = false)
    @JsonIgnore
    @TableField(exist = false)//关系主表数据
    private OrgSector dstorgsector;
    @JSONField(serialize = false)
    @JsonIgnore
    @TableField(exist = false)//关系主表数据
    private Org dstorg;
    @Dict(dictName = "ionicdemo_URDBCDRCodeList")
    private Integer bcdr;
    @PreField(fill= FillMode.INSERT,preType = PredefinedType.CREATEDATE)
    private Timestamp createdate;
    @PreField(fill= FillMode.INSERT,preType = PredefinedType.CREATEMAN)
    @Dict(dictName = "ionicdemo_SysOperatorCodeList")
    private String createman;
    private String deid;
    @TableField(exist = false)//逻辑属性
    private String dename;
    private String dstorgid;
    @TableField(exist = false)//逻辑属性
    private String dstorgname;
    private String dstorgsectorid;
    @TableField(exist = false)//逻辑属性
    private String dstorgsectorname;
    private String dstsecbc;
    @Dict(dictName = "ionicdemo_YesNoCodeList")
    private Integer isalldata;
    private String memo;
    @Dict(dictName = "ionicdemo_URDOrgDRCodeList")
    private Integer orgdr;
    private String reserver;
    private String reserver2;
    private String reserver3;
    private String reserver4;
    @Dict(dictName = "ionicdemo_URDSecDRCodeList")
    private Integer secdr;
    @Dict(dictName = "ionicdemo_YesNoCodeList")
    private Integer srfsyspub;
    @Dict(dictName = "ionicdemo_YesNoCodeList")
    private Integer srfuserpub;
    private Integer udversion;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.UPDATEDATE)
    private Timestamp updatedate;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.UPDATEMAN)
    @Dict(dictName = "ionicdemo_SysOperatorCodeList")
    private String updateman;
    @Dict(dictName = "ionicdemo_URDUserDRCodeList")
    private Integer userdr;
    @TableId(value= "userroledataid",type=IdType.UUID)//指定主键生成策略
    private String userroledataid;
    private String userroledataname;
    /**
     *  设置属性值[条线数据类型]
     *  @param bcdr
     */
    public void setBcdr(Integer bcdr){
        this.bcdr = bcdr;
        this.set("bcdrdirtyflag",true);
    }
    /**
     *  获取属性值[条线数据类型]
     */
    public Integer getBcdr(){
        return this.bcdr;
    }
    /**
     *  重置属性值[条线数据类型]
     */
    public void resetBcdr(){
        this.set("bcdrdirtyflag",false);
        this.bcdr = null;
    }
    /**
     *  设置属性值[建立时间]
     *  @param createdate
     */
    public void setCreatedate(Timestamp createdate){
        this.createdate = createdate;
        this.set("createdatedirtyflag",true);
    }
    /**
     *  获取属性值[建立时间]
     */
    public Timestamp getCreatedate(){
        return this.createdate;
    }
    /**
     *  重置属性值[建立时间]
     */
    public void resetCreatedate(){
        this.set("createdatedirtyflag",false);
        this.createdate = null;
    }
    /**
     *  设置属性值[建立人]
     *  @param createman
     */
    public void setCreateman(String createman){
        if(StringUtils.isEmpty(createman))
            createman=null;
        this.createman = createman;
        this.set("createmandirtyflag",true);
    }
    /**
     *  获取属性值[建立人]
     */
    public String getCreateman(){
        return this.createman;
    }
    /**
     *  重置属性值[建立人]
     */
    public void resetCreateman(){
        this.set("createmandirtyflag",false);
        this.createman = null;
    }
    /**
     *  设置属性值[数据实体]
     *  @param deid
     */
    public void setDeid(String deid){
        if(StringUtils.isEmpty(deid))
            deid=null;
        this.deid = deid;
        this.set("deiddirtyflag",true);
    }
    /**
     *  获取属性值[数据实体]
     */
    public String getDeid(){
        return this.deid;
    }
    /**
     *  重置属性值[数据实体]
     */
    public void resetDeid(){
        this.set("deiddirtyflag",false);
        this.deid = null;
    }
    /**
     *  设置属性值[数据对象]
     *  @param dename
     */
    public void setDename(String dename){
        if(StringUtils.isEmpty(dename))
            dename=null;
        this.dename = dename;
        this.set("denamedirtyflag",true);
    }
    /**
     *  获取属性值[数据对象]
     */
    public String getDename(){
        return this.dename;
    }
    /**
     *  重置属性值[数据对象]
     */
    public void resetDename(){
        this.set("denamedirtyflag",false);
        this.dename = null;
    }
    /**
     *  设置属性值[指定当前机构]
     *  @param dstorgid
     */
    public void setDstorgid(String dstorgid){
        if(StringUtils.isEmpty(dstorgid))
            dstorgid=null;
        this.dstorgid = dstorgid;
        this.set("dstorgiddirtyflag",true);
    }
    /**
     *  获取属性值[指定当前机构]
     */
    public String getDstorgid(){
        return this.dstorgid;
    }
    /**
     *  重置属性值[指定当前机构]
     */
    public void resetDstorgid(){
        this.set("dstorgiddirtyflag",false);
        this.dstorgid = null;
    }
    /**
     *  设置属性值[指定当前机构]
     *  @param dstorgname
     */
    public void setDstorgname(String dstorgname){
        if(StringUtils.isEmpty(dstorgname))
            dstorgname=null;
        this.dstorgname = dstorgname;
        this.set("dstorgnamedirtyflag",true);
    }
    /**
     *  获取属性值[指定当前机构]
     */
    public String getDstorgname(){
        return this.dstorgname;
    }
    /**
     *  重置属性值[指定当前机构]
     */
    public void resetDstorgname(){
        this.set("dstorgnamedirtyflag",false);
        this.dstorgname = null;
    }
    /**
     *  设置属性值[指定当前部门]
     *  @param dstorgsectorid
     */
    public void setDstorgsectorid(String dstorgsectorid){
        if(StringUtils.isEmpty(dstorgsectorid))
            dstorgsectorid=null;
        this.dstorgsectorid = dstorgsectorid;
        this.set("dstorgsectoriddirtyflag",true);
    }
    /**
     *  获取属性值[指定当前部门]
     */
    public String getDstorgsectorid(){
        return this.dstorgsectorid;
    }
    /**
     *  重置属性值[指定当前部门]
     */
    public void resetDstorgsectorid(){
        this.set("dstorgsectoriddirtyflag",false);
        this.dstorgsectorid = null;
    }
    /**
     *  设置属性值[指定当前部门]
     *  @param dstorgsectorname
     */
    public void setDstorgsectorname(String dstorgsectorname){
        if(StringUtils.isEmpty(dstorgsectorname))
            dstorgsectorname=null;
        this.dstorgsectorname = dstorgsectorname;
        this.set("dstorgsectornamedirtyflag",true);
    }
    /**
     *  获取属性值[指定当前部门]
     */
    public String getDstorgsectorname(){
        return this.dstorgsectorname;
    }
    /**
     *  重置属性值[指定当前部门]
     */
    public void resetDstorgsectorname(){
        this.set("dstorgsectornamedirtyflag",false);
        this.dstorgsectorname = null;
    }
    /**
     *  设置属性值[指定部门业务类型]
     *  @param dstsecbc
     */
    public void setDstsecbc(String dstsecbc){
        if(StringUtils.isEmpty(dstsecbc))
            dstsecbc=null;
        this.dstsecbc = dstsecbc;
        this.set("dstsecbcdirtyflag",true);
    }
    /**
     *  获取属性值[指定部门业务类型]
     */
    public String getDstsecbc(){
        return this.dstsecbc;
    }
    /**
     *  重置属性值[指定部门业务类型]
     */
    public void resetDstsecbc(){
        this.set("dstsecbcdirtyflag",false);
        this.dstsecbc = null;
    }
    /**
     *  设置属性值[全部数据]
     *  @param isalldata
     */
    public void setIsalldata(Integer isalldata){
        this.isalldata = isalldata;
        this.set("isalldatadirtyflag",true);
    }
    /**
     *  获取属性值[全部数据]
     */
    public Integer getIsalldata(){
        return this.isalldata;
    }
    /**
     *  重置属性值[全部数据]
     */
    public void resetIsalldata(){
        this.set("isalldatadirtyflag",false);
        this.isalldata = null;
    }
    /**
     *  设置属性值[备注]
     *  @param memo
     */
    public void setMemo(String memo){
        if(StringUtils.isEmpty(memo))
            memo=null;
        this.memo = memo;
        this.set("memodirtyflag",true);
    }
    /**
     *  获取属性值[备注]
     */
    public String getMemo(){
        return this.memo;
    }
    /**
     *  重置属性值[备注]
     */
    public void resetMemo(){
        this.set("memodirtyflag",false);
        this.memo = null;
    }
    /**
     *  设置属性值[机构数据类型]
     *  @param orgdr
     */
    public void setOrgdr(Integer orgdr){
        this.orgdr = orgdr;
        this.set("orgdrdirtyflag",true);
    }
    /**
     *  获取属性值[机构数据类型]
     */
    public Integer getOrgdr(){
        return this.orgdr;
    }
    /**
     *  重置属性值[机构数据类型]
     */
    public void resetOrgdr(){
        this.set("orgdrdirtyflag",false);
        this.orgdr = null;
    }
    /**
     *  设置属性值[保留字段]
     *  @param reserver
     */
    public void setReserver(String reserver){
        if(StringUtils.isEmpty(reserver))
            reserver=null;
        this.reserver = reserver;
        this.set("reserverdirtyflag",true);
    }
    /**
     *  获取属性值[保留字段]
     */
    public String getReserver(){
        return this.reserver;
    }
    /**
     *  重置属性值[保留字段]
     */
    public void resetReserver(){
        this.set("reserverdirtyflag",false);
        this.reserver = null;
    }
    /**
     *  设置属性值[保留字段2]
     *  @param reserver2
     */
    public void setReserver2(String reserver2){
        if(StringUtils.isEmpty(reserver2))
            reserver2=null;
        this.reserver2 = reserver2;
        this.set("reserver2dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段2]
     */
    public String getReserver2(){
        return this.reserver2;
    }
    /**
     *  重置属性值[保留字段2]
     */
    public void resetReserver2(){
        this.set("reserver2dirtyflag",false);
        this.reserver2 = null;
    }
    /**
     *  设置属性值[保留字段3]
     *  @param reserver3
     */
    public void setReserver3(String reserver3){
        if(StringUtils.isEmpty(reserver3))
            reserver3=null;
        this.reserver3 = reserver3;
        this.set("reserver3dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段3]
     */
    public String getReserver3(){
        return this.reserver3;
    }
    /**
     *  重置属性值[保留字段3]
     */
    public void resetReserver3(){
        this.set("reserver3dirtyflag",false);
        this.reserver3 = null;
    }
    /**
     *  设置属性值[保留字段4]
     *  @param reserver4
     */
    public void setReserver4(String reserver4){
        if(StringUtils.isEmpty(reserver4))
            reserver4=null;
        this.reserver4 = reserver4;
        this.set("reserver4dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段4]
     */
    public String getReserver4(){
        return this.reserver4;
    }
    /**
     *  重置属性值[保留字段4]
     */
    public void resetReserver4(){
        this.set("reserver4dirtyflag",false);
        this.reserver4 = null;
    }
    /**
     *  设置属性值[部门数据类型]
     *  @param secdr
     */
    public void setSecdr(Integer secdr){
        this.secdr = secdr;
        this.set("secdrdirtyflag",true);
    }
    /**
     *  获取属性值[部门数据类型]
     */
    public Integer getSecdr(){
        return this.secdr;
    }
    /**
     *  重置属性值[部门数据类型]
     */
    public void resetSecdr(){
        this.set("secdrdirtyflag",false);
        this.secdr = null;
    }
    /**
     *  设置属性值[框架发布]
     *  @param srfsyspub
     */
    public void setSrfsyspub(Integer srfsyspub){
        this.srfsyspub = srfsyspub;
        this.set("srfsyspubdirtyflag",true);
    }
    /**
     *  获取属性值[框架发布]
     */
    public Integer getSrfsyspub(){
        return this.srfsyspub;
    }
    /**
     *  重置属性值[框架发布]
     */
    public void resetSrfsyspub(){
        this.set("srfsyspubdirtyflag",false);
        this.srfsyspub = null;
    }
    /**
     *  设置属性值[应用发布]
     *  @param srfuserpub
     */
    public void setSrfuserpub(Integer srfuserpub){
        this.srfuserpub = srfuserpub;
        this.set("srfuserpubdirtyflag",true);
    }
    /**
     *  获取属性值[应用发布]
     */
    public Integer getSrfuserpub(){
        return this.srfuserpub;
    }
    /**
     *  重置属性值[应用发布]
     */
    public void resetSrfuserpub(){
        this.set("srfuserpubdirtyflag",false);
        this.srfuserpub = null;
    }
    /**
     *  设置属性值[版本]
     *  @param udversion
     */
    public void setUdversion(Integer udversion){
        this.udversion = udversion;
        this.set("udversiondirtyflag",true);
    }
    /**
     *  获取属性值[版本]
     */
    public Integer getUdversion(){
        return this.udversion;
    }
    /**
     *  重置属性值[版本]
     */
    public void resetUdversion(){
        this.set("udversiondirtyflag",false);
        this.udversion = null;
    }
    /**
     *  设置属性值[更新时间]
     *  @param updatedate
     */
    public void setUpdatedate(Timestamp updatedate){
        this.updatedate = updatedate;
        this.set("updatedatedirtyflag",true);
    }
    /**
     *  获取属性值[更新时间]
     */
    public Timestamp getUpdatedate(){
        return this.updatedate;
    }
    /**
     *  重置属性值[更新时间]
     */
    public void resetUpdatedate(){
        this.set("updatedatedirtyflag",false);
        this.updatedate = null;
    }
    /**
     *  设置属性值[更新人]
     *  @param updateman
     */
    public void setUpdateman(String updateman){
        if(StringUtils.isEmpty(updateman))
            updateman=null;
        this.updateman = updateman;
        this.set("updatemandirtyflag",true);
    }
    /**
     *  获取属性值[更新人]
     */
    public String getUpdateman(){
        return this.updateman;
    }
    /**
     *  重置属性值[更新人]
     */
    public void resetUpdateman(){
        this.set("updatemandirtyflag",false);
        this.updateman = null;
    }
    /**
     *  设置属性值[用户数据类型]
     *  @param userdr
     */
    public void setUserdr(Integer userdr){
        this.userdr = userdr;
        this.set("userdrdirtyflag",true);
    }
    /**
     *  获取属性值[用户数据类型]
     */
    public Integer getUserdr(){
        return this.userdr;
    }
    /**
     *  重置属性值[用户数据类型]
     */
    public void resetUserdr(){
        this.set("userdrdirtyflag",false);
        this.userdr = null;
    }
    /**
     *  设置属性值[数据对象能力标识]
     *  @param userroledataid
     */
    public void setUserroledataid(String userroledataid){
        if(StringUtils.isEmpty(userroledataid))
            userroledataid=null;
        this.userroledataid = userroledataid;
        this.set("userroledataiddirtyflag",true);
    }
    /**
     *  获取属性值[数据对象能力标识]
     */
    public String getUserroledataid(){
        return this.userroledataid;
    }
    /**
     *  重置属性值[数据对象能力标识]
     */
    public void resetUserroledataid(){
        this.set("userroledataiddirtyflag",false);
        this.userroledataid = null;
    }
    /**
     *  设置属性值[能力名称]
     *  @param userroledataname
     */
    public void setUserroledataname(String userroledataname){
        if(StringUtils.isEmpty(userroledataname))
            userroledataname=null;
        this.userroledataname = userroledataname;
        this.set("userroledatanamedirtyflag",true);
    }
    /**
     *  获取属性值[能力名称]
     */
    public String getUserroledataname(){
        return this.userroledataname;
    }
    /**
     *  重置属性值[能力名称]
     */
    public void resetUserroledataname(){
        this.set("userroledatanamedirtyflag",false);
        this.userroledataname = null;
    }
     /**
     *  获取主实体关联数据[DataEntity]
     */
    public DataEntity getDe() {
        return de;
    }
    /**
     *  设置主实体关联数据[DataEntity]
     */
    public void setDe(DataEntity de) {
        this.de = de;
    }

     /**
     *  获取主实体关联数据[OrgSector]
     */
    public OrgSector getDstorgsector() {
        return dstorgsector;
    }
    /**
     *  设置主实体关联数据[OrgSector]
     */
    public void setDstorgsector(OrgSector dstorgsector) {
        this.dstorgsector = dstorgsector;
    }

     /**
     *  获取主实体关联数据[Org]
     */
    public Org getDstorg() {
        return dstorg;
    }
    /**
     *  设置主实体关联数据[Org]
     */
    public void setDstorg(Org dstorg) {
        this.dstorg = dstorg;
    }

    /**
     * 重置当前数据对象属性值
     */
    public  void reset(){
        resetBcdr();
        resetCreatedate();
        resetCreateman();
        resetDeid();
        resetDename();
        resetDstorgid();
        resetDstorgname();
        resetDstorgsectorid();
        resetDstorgsectorname();
        resetDstsecbc();
        resetIsalldata();
        resetMemo();
        resetOrgdr();
        resetReserver();
        resetReserver2();
        resetReserver3();
        resetReserver4();
        resetSecdr();
        resetSrfsyspub();
        resetSrfuserpub();
        resetUdversion();
        resetUpdatedate();
        resetUpdateman();
        resetUserdr();
        resetUserroledataid();
        resetUserroledataname();
    }
     /**
     * 获取数据主键（普通主键与联合主键）
     * @return
     */
    @JsonIgnore
    public Serializable getDefaultPrimaryKey()
    {
	    //随机生成主键
         return  IdWorker.get32UUID();

    }
     /**
     * 复制当前对象数据到目标对象(粘贴重置)
     *
     * @throws Exception
     */
    public UserRoleData copyTo(UserRoleData targetEntity)
	{
		BeanCopier copier=BeanCopier.create(UserRoleData.class, UserRoleData.class, false);
		copier.copy(this, targetEntity, null);
        targetEntity.resetUserroledataid();
		return targetEntity;
	}
}