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;


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

    @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 memo;
    private Integer ordervalue;
    @TableId(value= "orgsecusertypeid",type=IdType.UUID)//指定主键生成策略
    private String orgsecusertypeid;
    private String orgsecusertypename;
    private String reserver;
    private String reserver10;
    private Integer reserver11;
    private Integer reserver12;
    private Integer reserver13;
    private Integer reserver14;
    private Double reserver15;
    private Double reserver16;
    private Double reserver17;
    private Double reserver18;
    private Timestamp reserver19;
    private String reserver2;
    private Timestamp reserver20;
    private Timestamp reserver21;
    private Timestamp reserver22;
    private String reserver23;
    private String reserver24;
    private String reserver25;
    private String reserver26;
    private String reserver27;
    private String reserver28;
    private String reserver29;
    private String reserver3;
    private String reserver30;
    private String reserver4;
    private String reserver5;
    private String reserver6;
    private String reserver7;
    private String reserver8;
    private String reserver9;
    private String typecode;
    @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_YesNoCodeList")
    private Integer validflag;
    /**
     *  设置属性值[建立时间]
     *  @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 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 ordervalue
     */
    public void setOrdervalue(Integer ordervalue){
        this.ordervalue = ordervalue;
        this.set("ordervaluedirtyflag",true);
    }
    /**
     *  获取属性值[排序值]
     */
    public Integer getOrdervalue(){
        return this.ordervalue;
    }
    /**
     *  重置属性值[排序值]
     */
    public void resetOrdervalue(){
        this.set("ordervaluedirtyflag",false);
        this.ordervalue = null;
    }
    /**
     *  设置属性值[部门人员关系类型标识]
     *  @param orgsecusertypeid
     */
    public void setOrgsecusertypeid(String orgsecusertypeid){
        if(StringUtils.isEmpty(orgsecusertypeid))
            orgsecusertypeid=null;
        this.orgsecusertypeid = orgsecusertypeid;
        this.set("orgsecusertypeiddirtyflag",true);
    }
    /**
     *  获取属性值[部门人员关系类型标识]
     */
    public String getOrgsecusertypeid(){
        return this.orgsecusertypeid;
    }
    /**
     *  重置属性值[部门人员关系类型标识]
     */
    public void resetOrgsecusertypeid(){
        this.set("orgsecusertypeiddirtyflag",false);
        this.orgsecusertypeid = null;
    }
    /**
     *  设置属性值[部门人员关系类型名称]
     *  @param orgsecusertypename
     */
    public void setOrgsecusertypename(String orgsecusertypename){
        if(StringUtils.isEmpty(orgsecusertypename))
            orgsecusertypename=null;
        this.orgsecusertypename = orgsecusertypename;
        this.set("orgsecusertypenamedirtyflag",true);
    }
    /**
     *  获取属性值[部门人员关系类型名称]
     */
    public String getOrgsecusertypename(){
        return this.orgsecusertypename;
    }
    /**
     *  重置属性值[部门人员关系类型名称]
     */
    public void resetOrgsecusertypename(){
        this.set("orgsecusertypenamedirtyflag",false);
        this.orgsecusertypename = 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;
    }
    /**
     *  设置属性值[保留字段10]
     *  @param reserver10
     */
    public void setReserver10(String reserver10){
        if(StringUtils.isEmpty(reserver10))
            reserver10=null;
        this.reserver10 = reserver10;
        this.set("reserver10dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段10]
     */
    public String getReserver10(){
        return this.reserver10;
    }
    /**
     *  重置属性值[保留字段10]
     */
    public void resetReserver10(){
        this.set("reserver10dirtyflag",false);
        this.reserver10 = null;
    }
    /**
     *  设置属性值[保留字段11]
     *  @param reserver11
     */
    public void setReserver11(Integer reserver11){
        this.reserver11 = reserver11;
        this.set("reserver11dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段11]
     */
    public Integer getReserver11(){
        return this.reserver11;
    }
    /**
     *  重置属性值[保留字段11]
     */
    public void resetReserver11(){
        this.set("reserver11dirtyflag",false);
        this.reserver11 = null;
    }
    /**
     *  设置属性值[保留字段12]
     *  @param reserver12
     */
    public void setReserver12(Integer reserver12){
        this.reserver12 = reserver12;
        this.set("reserver12dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段12]
     */
    public Integer getReserver12(){
        return this.reserver12;
    }
    /**
     *  重置属性值[保留字段12]
     */
    public void resetReserver12(){
        this.set("reserver12dirtyflag",false);
        this.reserver12 = null;
    }
    /**
     *  设置属性值[保留字段13]
     *  @param reserver13
     */
    public void setReserver13(Integer reserver13){
        this.reserver13 = reserver13;
        this.set("reserver13dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段13]
     */
    public Integer getReserver13(){
        return this.reserver13;
    }
    /**
     *  重置属性值[保留字段13]
     */
    public void resetReserver13(){
        this.set("reserver13dirtyflag",false);
        this.reserver13 = null;
    }
    /**
     *  设置属性值[保留字段14]
     *  @param reserver14
     */
    public void setReserver14(Integer reserver14){
        this.reserver14 = reserver14;
        this.set("reserver14dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段14]
     */
    public Integer getReserver14(){
        return this.reserver14;
    }
    /**
     *  重置属性值[保留字段14]
     */
    public void resetReserver14(){
        this.set("reserver14dirtyflag",false);
        this.reserver14 = null;
    }
    /**
     *  设置属性值[保留字段15]
     *  @param reserver15
     */
    public void setReserver15(Double reserver15){
        this.reserver15 = reserver15;
        this.set("reserver15dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段15]
     */
    public Double getReserver15(){
        return this.reserver15;
    }
    /**
     *  重置属性值[保留字段15]
     */
    public void resetReserver15(){
        this.set("reserver15dirtyflag",false);
        this.reserver15 = null;
    }
    /**
     *  设置属性值[保留字段16]
     *  @param reserver16
     */
    public void setReserver16(Double reserver16){
        this.reserver16 = reserver16;
        this.set("reserver16dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段16]
     */
    public Double getReserver16(){
        return this.reserver16;
    }
    /**
     *  重置属性值[保留字段16]
     */
    public void resetReserver16(){
        this.set("reserver16dirtyflag",false);
        this.reserver16 = null;
    }
    /**
     *  设置属性值[保留字段17]
     *  @param reserver17
     */
    public void setReserver17(Double reserver17){
        this.reserver17 = reserver17;
        this.set("reserver17dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段17]
     */
    public Double getReserver17(){
        return this.reserver17;
    }
    /**
     *  重置属性值[保留字段17]
     */
    public void resetReserver17(){
        this.set("reserver17dirtyflag",false);
        this.reserver17 = null;
    }
    /**
     *  设置属性值[保留字段18]
     *  @param reserver18
     */
    public void setReserver18(Double reserver18){
        this.reserver18 = reserver18;
        this.set("reserver18dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段18]
     */
    public Double getReserver18(){
        return this.reserver18;
    }
    /**
     *  重置属性值[保留字段18]
     */
    public void resetReserver18(){
        this.set("reserver18dirtyflag",false);
        this.reserver18 = null;
    }
    /**
     *  设置属性值[保留字段19]
     *  @param reserver19
     */
    public void setReserver19(Timestamp reserver19){
        this.reserver19 = reserver19;
        this.set("reserver19dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段19]
     */
    public Timestamp getReserver19(){
        return this.reserver19;
    }
    /**
     *  重置属性值[保留字段19]
     */
    public void resetReserver19(){
        this.set("reserver19dirtyflag",false);
        this.reserver19 = 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;
    }
    /**
     *  设置属性值[保留字段20]
     *  @param reserver20
     */
    public void setReserver20(Timestamp reserver20){
        this.reserver20 = reserver20;
        this.set("reserver20dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段20]
     */
    public Timestamp getReserver20(){
        return this.reserver20;
    }
    /**
     *  重置属性值[保留字段20]
     */
    public void resetReserver20(){
        this.set("reserver20dirtyflag",false);
        this.reserver20 = null;
    }
    /**
     *  设置属性值[保留字段21]
     *  @param reserver21
     */
    public void setReserver21(Timestamp reserver21){
        this.reserver21 = reserver21;
        this.set("reserver21dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段21]
     */
    public Timestamp getReserver21(){
        return this.reserver21;
    }
    /**
     *  重置属性值[保留字段21]
     */
    public void resetReserver21(){
        this.set("reserver21dirtyflag",false);
        this.reserver21 = null;
    }
    /**
     *  设置属性值[保留字段22]
     *  @param reserver22
     */
    public void setReserver22(Timestamp reserver22){
        this.reserver22 = reserver22;
        this.set("reserver22dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段22]
     */
    public Timestamp getReserver22(){
        return this.reserver22;
    }
    /**
     *  重置属性值[保留字段22]
     */
    public void resetReserver22(){
        this.set("reserver22dirtyflag",false);
        this.reserver22 = null;
    }
    /**
     *  设置属性值[保留字段23]
     *  @param reserver23
     */
    public void setReserver23(String reserver23){
        if(StringUtils.isEmpty(reserver23))
            reserver23=null;
        this.reserver23 = reserver23;
        this.set("reserver23dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段23]
     */
    public String getReserver23(){
        return this.reserver23;
    }
    /**
     *  重置属性值[保留字段23]
     */
    public void resetReserver23(){
        this.set("reserver23dirtyflag",false);
        this.reserver23 = null;
    }
    /**
     *  设置属性值[保留字段24]
     *  @param reserver24
     */
    public void setReserver24(String reserver24){
        if(StringUtils.isEmpty(reserver24))
            reserver24=null;
        this.reserver24 = reserver24;
        this.set("reserver24dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段24]
     */
    public String getReserver24(){
        return this.reserver24;
    }
    /**
     *  重置属性值[保留字段24]
     */
    public void resetReserver24(){
        this.set("reserver24dirtyflag",false);
        this.reserver24 = null;
    }
    /**
     *  设置属性值[保留字段25]
     *  @param reserver25
     */
    public void setReserver25(String reserver25){
        if(StringUtils.isEmpty(reserver25))
            reserver25=null;
        this.reserver25 = reserver25;
        this.set("reserver25dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段25]
     */
    public String getReserver25(){
        return this.reserver25;
    }
    /**
     *  重置属性值[保留字段25]
     */
    public void resetReserver25(){
        this.set("reserver25dirtyflag",false);
        this.reserver25 = null;
    }
    /**
     *  设置属性值[保留字段26]
     *  @param reserver26
     */
    public void setReserver26(String reserver26){
        if(StringUtils.isEmpty(reserver26))
            reserver26=null;
        this.reserver26 = reserver26;
        this.set("reserver26dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段26]
     */
    public String getReserver26(){
        return this.reserver26;
    }
    /**
     *  重置属性值[保留字段26]
     */
    public void resetReserver26(){
        this.set("reserver26dirtyflag",false);
        this.reserver26 = null;
    }
    /**
     *  设置属性值[保留字段27]
     *  @param reserver27
     */
    public void setReserver27(String reserver27){
        if(StringUtils.isEmpty(reserver27))
            reserver27=null;
        this.reserver27 = reserver27;
        this.set("reserver27dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段27]
     */
    public String getReserver27(){
        return this.reserver27;
    }
    /**
     *  重置属性值[保留字段27]
     */
    public void resetReserver27(){
        this.set("reserver27dirtyflag",false);
        this.reserver27 = null;
    }
    /**
     *  设置属性值[保留字段28]
     *  @param reserver28
     */
    public void setReserver28(String reserver28){
        if(StringUtils.isEmpty(reserver28))
            reserver28=null;
        this.reserver28 = reserver28;
        this.set("reserver28dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段28]
     */
    public String getReserver28(){
        return this.reserver28;
    }
    /**
     *  重置属性值[保留字段28]
     */
    public void resetReserver28(){
        this.set("reserver28dirtyflag",false);
        this.reserver28 = null;
    }
    /**
     *  设置属性值[保留字段29]
     *  @param reserver29
     */
    public void setReserver29(String reserver29){
        if(StringUtils.isEmpty(reserver29))
            reserver29=null;
        this.reserver29 = reserver29;
        this.set("reserver29dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段29]
     */
    public String getReserver29(){
        return this.reserver29;
    }
    /**
     *  重置属性值[保留字段29]
     */
    public void resetReserver29(){
        this.set("reserver29dirtyflag",false);
        this.reserver29 = 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;
    }
    /**
     *  设置属性值[保留字段30]
     *  @param reserver30
     */
    public void setReserver30(String reserver30){
        if(StringUtils.isEmpty(reserver30))
            reserver30=null;
        this.reserver30 = reserver30;
        this.set("reserver30dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段30]
     */
    public String getReserver30(){
        return this.reserver30;
    }
    /**
     *  重置属性值[保留字段30]
     */
    public void resetReserver30(){
        this.set("reserver30dirtyflag",false);
        this.reserver30 = 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;
    }
    /**
     *  设置属性值[保留字段5]
     *  @param reserver5
     */
    public void setReserver5(String reserver5){
        if(StringUtils.isEmpty(reserver5))
            reserver5=null;
        this.reserver5 = reserver5;
        this.set("reserver5dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段5]
     */
    public String getReserver5(){
        return this.reserver5;
    }
    /**
     *  重置属性值[保留字段5]
     */
    public void resetReserver5(){
        this.set("reserver5dirtyflag",false);
        this.reserver5 = null;
    }
    /**
     *  设置属性值[保留字段6]
     *  @param reserver6
     */
    public void setReserver6(String reserver6){
        if(StringUtils.isEmpty(reserver6))
            reserver6=null;
        this.reserver6 = reserver6;
        this.set("reserver6dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段6]
     */
    public String getReserver6(){
        return this.reserver6;
    }
    /**
     *  重置属性值[保留字段6]
     */
    public void resetReserver6(){
        this.set("reserver6dirtyflag",false);
        this.reserver6 = null;
    }
    /**
     *  设置属性值[保留字段7]
     *  @param reserver7
     */
    public void setReserver7(String reserver7){
        if(StringUtils.isEmpty(reserver7))
            reserver7=null;
        this.reserver7 = reserver7;
        this.set("reserver7dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段7]
     */
    public String getReserver7(){
        return this.reserver7;
    }
    /**
     *  重置属性值[保留字段7]
     */
    public void resetReserver7(){
        this.set("reserver7dirtyflag",false);
        this.reserver7 = null;
    }
    /**
     *  设置属性值[保留字段8]
     *  @param reserver8
     */
    public void setReserver8(String reserver8){
        if(StringUtils.isEmpty(reserver8))
            reserver8=null;
        this.reserver8 = reserver8;
        this.set("reserver8dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段8]
     */
    public String getReserver8(){
        return this.reserver8;
    }
    /**
     *  重置属性值[保留字段8]
     */
    public void resetReserver8(){
        this.set("reserver8dirtyflag",false);
        this.reserver8 = null;
    }
    /**
     *  设置属性值[保留字段9]
     *  @param reserver9
     */
    public void setReserver9(String reserver9){
        if(StringUtils.isEmpty(reserver9))
            reserver9=null;
        this.reserver9 = reserver9;
        this.set("reserver9dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段9]
     */
    public String getReserver9(){
        return this.reserver9;
    }
    /**
     *  重置属性值[保留字段9]
     */
    public void resetReserver9(){
        this.set("reserver9dirtyflag",false);
        this.reserver9 = null;
    }
    /**
     *  设置属性值[类型代码]
     *  @param typecode
     */
    public void setTypecode(String typecode){
        if(StringUtils.isEmpty(typecode))
            typecode=null;
        this.typecode = typecode;
        this.set("typecodedirtyflag",true);
    }
    /**
     *  获取属性值[类型代码]
     */
    public String getTypecode(){
        return this.typecode;
    }
    /**
     *  重置属性值[类型代码]
     */
    public void resetTypecode(){
        this.set("typecodedirtyflag",false);
        this.typecode = 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 validflag
     */
    public void setValidflag(Integer validflag){
        this.validflag = validflag;
        this.set("validflagdirtyflag",true);
    }
    /**
     *  获取属性值[启用标志]
     */
    public Integer getValidflag(){
        return this.validflag;
    }
    /**
     *  重置属性值[启用标志]
     */
    public void resetValidflag(){
        this.set("validflagdirtyflag",false);
        this.validflag = null;
    }
    /**
     * 重置当前数据对象属性值
     */
    public  void reset(){
        resetCreatedate();
        resetCreateman();
        resetMemo();
        resetOrdervalue();
        resetOrgsecusertypeid();
        resetOrgsecusertypename();
        resetReserver();
        resetReserver10();
        resetReserver11();
        resetReserver12();
        resetReserver13();
        resetReserver14();
        resetReserver15();
        resetReserver16();
        resetReserver17();
        resetReserver18();
        resetReserver19();
        resetReserver2();
        resetReserver20();
        resetReserver21();
        resetReserver22();
        resetReserver23();
        resetReserver24();
        resetReserver25();
        resetReserver26();
        resetReserver27();
        resetReserver28();
        resetReserver29();
        resetReserver3();
        resetReserver30();
        resetReserver4();
        resetReserver5();
        resetReserver6();
        resetReserver7();
        resetReserver8();
        resetReserver9();
        resetTypecode();
        resetUpdatedate();
        resetUpdateman();
        resetValidflag();
    }
     /**
     * 获取数据主键（普通主键与联合主键）
     * @return
     */
    @JsonIgnore
    public Serializable getDefaultPrimaryKey()
    {
	    //随机生成主键
         return  IdWorker.get32UUID();

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