namespace WX.CRM.Model.Entity
{
    using System.Data.Entity;

    public partial class SqlDbContext : DbContext
    {
        //ΔΟΎ©
        public SqlDbContext()
            : base(ConStringHelper.GetDbConnection("DATA SOURCE=192.168.66.14:1521/ORCL;PERSIST SECURITY INFO=True;USER ID=UPDEV;PASSWORD=sa123456."), true)
        {

        }

        //public SqlDbContext()
        //: base(ConStringHelper.GetDbConnection("DATA SOURCE=192.168.1.133:1521/CRMHQ;PERSIST SECURITY INFO=True;USER ID=UPDEV;PASSWORD=sa123456."), true)
        //{

        //}

        public virtual DbSet<BAS_BUSINESS> BAS_BUSINESS { get; set; }
        public virtual DbSet<BAS_BUSINESSTYPE> BAS_BUSINESSTYPE { get; set; }
        public virtual DbSet<BAS_CITY> BAS_CITY { get; set; }
        public virtual DbSet<BAS_COMPANY> BAS_COMPANY { get; set; }
        public virtual DbSet<BAS_COMPANYCAMPAIN> BAS_COMPANYCAMPAIN { get; set; }
        public virtual DbSet<BAS_COMTYPE> BAS_COMTYPE { get; set; }
        public virtual DbSet<BAS_DAILYMEMU> BAS_DAILYMEMU { get; set; }

        public virtual DbSet<BAS_GROUPLEADER> BAS_GROUPLEADER { get; set; }
        public virtual DbSet<BAS_INNERDEPARTMENT> BAS_INNERDEPARTMENT { get; set; }
        public virtual DbSet<BAS_INNERGROUP> BAS_INNERGROUP { get; set; }
        public virtual DbSet<BAS_INNERUSER> BAS_INNERUSER { get; set; }
        public virtual DbSet<BAS_INNERUSER_EXT> BAS_INNERUSER_EXT { get; set; }
        public virtual DbSet<BAS_INNERUSER_EXT_LOG> BAS_INNERUSER_EXT_LOG { get; set; }
        public virtual DbSet<BAS_INNERUSERGROUP> BAS_INNERUSERGROUP { get; set; }
        public virtual DbSet<BAS_INNERUSERINFORMATIONTIPS> BAS_INNERUSERINFORMATIONTIPS { get; set; }
        public virtual DbSet<BAS_INNERUSERROLE> BAS_INNERUSERROLE { get; set; }
        public virtual DbSet<BAS_INNERUSERSALT> BAS_INNERUSERSALT { get; set; }
        public virtual DbSet<BAS_LEFTMEMU> BAS_LEFTMEMU { get; set; }
        public virtual DbSet<BAS_LOGINLOG> BAS_LOGINLOG { get; set; }
        public virtual DbSet<BAS_MOBILEAREA> BAS_MOBILEAREA { get; set; }
        public virtual DbSet<BAS_MODULEMENU> BAS_MODULEMENU { get; set; }
        public virtual DbSet<BAS_OPERATIONLOG> BAS_OPERATIONLOG { get; set; }
        public virtual DbSet<BAS_PARAMETER> BAS_PARAMETER { get; set; }
        public virtual DbSet<BAS_PARAMETERGROUP> BAS_PARAMETERGROUP { get; set; }
        public virtual DbSet<BAS_PROCEXECUTE_LOG> BAS_PROCEXECUTE_LOG { get; set; }
        public virtual DbSet<BAS_PROVINCE> BAS_PROVINCE { get; set; }
        public virtual DbSet<BAS_RIGHT> BAS_RIGHT { get; set; }
        public virtual DbSet<BAS_RIGHT_TOOLBUTTON> BAS_RIGHT_TOOLBUTTON { get; set; }
        public virtual DbSet<BAS_RIGHTGROUP> BAS_RIGHTGROUP { get; set; }
        public virtual DbSet<BAS_ROLE> BAS_ROLE { get; set; }
        public virtual DbSet<BAS_ROLERIGHTRESOURCE> BAS_ROLERIGHTRESOURCE { get; set; }
        public virtual DbSet<BAS_ROOM> BAS_ROOM { get; set; }
        public virtual DbSet<BAS_SALESDEPARTMENT> BAS_SALESDEPARTMENT { get; set; }
        public virtual DbSet<BAS_SUBCOMTYPE> BAS_SUBCOMTYPE { get; set; }
        public virtual DbSet<BAS_USERGROUPCHANGELOG> BAS_USERGROUPCHANGELOG { get; set; }
        public virtual DbSet<CACHE_ORD_MEMO> CACHE_ORD_MEMO { get; set; }
        public virtual DbSet<CACHE_QC_ORDMEMO> CACHE_QC_ORDMEMO { get; set; }
        public virtual DbSet<CACHE_RES_POOLLOG> CACHE_RES_POOLLOG { get; set; }
        public virtual DbSet<CACHE_RES_RESOURCE_COUNT> CACHE_RES_RESOURCE_COUNT { get; set; }
        public virtual DbSet<CSVR_APPLYPRIMARYNUMBER> CSVR_APPLYPRIMARYNUMBER { get; set; }
        public virtual DbSet<CSVR_APPLYVIP> CSVR_APPLYVIP { get; set; }
        public virtual DbSet<CSVR_BLACKNUMBER> CSVR_BLACKNUMBER { get; set; }
        public virtual DbSet<CSVR_CALLDATAREPORT> CSVR_CALLDATAREPORT { get; set; }
        public virtual DbSet<CSVR_CALLINLOG> CSVR_CALLINLOG { get; set; }
        public virtual DbSet<CSVR_CALLRECORD> CSVR_CALLRECORD { get; set; }
        public virtual DbSet<CSVR_CALLRECORD_HIS> CSVR_CALLRECORD_HIS { get; set; }
        public virtual DbSet<CSVR_CALLRECORD2> CSVR_CALLRECORD2 { get; set; }
        public virtual DbSet<CSVR_CALLRECORDDAYSTATISTICS> CSVR_CALLRECORDDAYSTATISTICS { get; set; }
        public virtual DbSet<CSVR_CALLRECORDUN> CSVR_CALLRECORDUN { get; set; }
        public virtual DbSet<CSVR_CALLSTATIS> CSVR_CALLSTATIS { get; set; }
        public virtual DbSet<CSVR_CALLSTATISDETAIL> CSVR_CALLSTATISDETAIL { get; set; }
        public virtual DbSet<CSVR_FAVORITECUSTOMER> CSVR_FAVORITECUSTOMER { get; set; }
        public virtual DbSet<CSVR_HGRECORD> CSVR_HGRECORD { get; set; }
        public virtual DbSet<CSVR_IDMAP> CSVR_IDMAP { get; set; }
        public virtual DbSet<CSVR_MSGOPENACCOUNT> CSVR_MSGOPENACCOUNT { get; set; }
        public virtual DbSet<CSVR_RECORDSHARED> CSVR_RECORDSHARED { get; set; }
        public virtual DbSet<CSVR_RECORDTYPE> CSVR_RECORDTYPE { get; set; }
        public virtual DbSet<CSVR_RELATIONCUSTOMER> CSVR_RELATIONCUSTOMER { get; set; }
        public virtual DbSet<CSVR_TODAYRECORD> CSVR_TODAYRECORD { get; set; }
        public virtual DbSet<CSVR_TODAYRECORDUN> CSVR_TODAYRECORDUN { get; set; }
        public virtual DbSet<CSVR_TODOITEM> CSVR_TODOITEM { get; set; }
        public virtual DbSet<CSVR_TODOSTATUS> CSVR_TODOSTATUS { get; set; }
        public virtual DbSet<CSVR_UNITECUSTOMERAPPLY> CSVR_UNITECUSTOMERAPPLY { get; set; }
        public virtual DbSet<CSVR_UNITECUSTOMERAPPLYDETAIL> CSVR_UNITECUSTOMERAPPLYDETAIL { get; set; }
        public virtual DbSet<HIS_BAS_LOGINLOG> HIS_BAS_LOGINLOG { get; set; }
        public virtual DbSet<HIS_BAS_OPERATIONLOG> HIS_BAS_OPERATIONLOG { get; set; }
        public virtual DbSet<HIS_ISVR_INTERFACECALLLOG> HIS_ISVR_INTERFACECALLLOG { get; set; }
        public virtual DbSet<HIS_ORD_MEMOCONTENT> HIS_ORD_MEMOCONTENT { get; set; }
        public virtual DbSet<HIS_ORD_PURPOSEMEMO> HIS_ORD_PURPOSEMEMO { get; set; }
        public virtual DbSet<HIS_ORD_SALEMEMO> HIS_ORD_SALEMEMO { get; set; }
        public virtual DbSet<HIS_ORD_SERVICEMEMO> HIS_ORD_SERVICEMEMO { get; set; }
        public virtual DbSet<HIS_ORD_SPECIALMEMO> HIS_ORD_SPECIALMEMO { get; set; }
        public virtual DbSet<HIS_SMS_BATCHMSG> HIS_SMS_BATCHMSG { get; set; }
        public virtual DbSet<HIS_SMS_BATCHMSGDETAIL_HIS> HIS_SMS_BATCHMSGDETAIL_HIS { get; set; }
        public virtual DbSet<HIS_SMS_MESSAGE_HIS> HIS_SMS_MESSAGE_HIS { get; set; }
        public virtual DbSet<HIS_SMS_SENDLOG> HIS_SMS_SENDLOG { get; set; }
        public virtual DbSet<ISVR_INTERFACECALLLOG> ISVR_INTERFACECALLLOG { get; set; }
        public virtual DbSet<ORD_HEGUIMEMO> ORD_HEGUIMEMO { get; set; }
        public virtual DbSet<ORD_MEMOCONTENT> ORD_MEMOCONTENT { get; set; }
        public virtual DbSet<ORD_MEMOSTYLE> ORD_MEMOSTYLE { get; set; }
        public virtual DbSet<ORD_MEMOSUBTYPE> ORD_MEMOSUBTYPE { get; set; }
        public virtual DbSet<ORD_MEMOTYPE> ORD_MEMOTYPE { get; set; }
        public virtual DbSet<ORD_PURPOSEMEMO> ORD_PURPOSEMEMO { get; set; }
        public virtual DbSet<ORD_SALEMEMO> ORD_SALEMEMO { get; set; }
        public virtual DbSet<ORD_SALEMEMO_HIS> ORD_SALEMEMO_HIS { get; set; }
        public virtual DbSet<ORD_SERVICEMEMO> ORD_SERVICEMEMO { get; set; }
        public virtual DbSet<ORD_SPECIALMEMO> ORD_SPECIALMEMO { get; set; }
        public virtual DbSet<QC_BAS_INNERUSER> QC_BAS_INNERUSER { get; set; }
        public virtual DbSet<QC_BASEUSERSCORE> QC_BASEUSERSCORE { get; set; }
        public virtual DbSet<QC_COMPLAINTDICT> QC_COMPLAINTDICT { get; set; }
        public virtual DbSet<QC_CUSTOMERCOMPLAIN> QC_CUSTOMERCOMPLAIN { get; set; }
        public virtual DbSet<QC_GROUPERSCOREDETAIL> QC_GROUPERSCOREDETAIL { get; set; }
        public virtual DbSet<QC_MEMOCONTENT> QC_MEMOCONTENT { get; set; }
        public virtual DbSet<QC_ORDMEMO> QC_ORDMEMO { get; set; }
        public virtual DbSet<QC_PURPOSEMEMO> QC_PURPOSEMEMO { get; set; }
        public virtual DbSet<QC_QUALITYTYPE> QC_QUALITYTYPE { get; set; }
        public virtual DbSet<QC_SALEMEMO> QC_SALEMEMO { get; set; }
        public virtual DbSet<QC_SERVICEMEMO> QC_SERVICEMEMO { get; set; }
        public virtual DbSet<QC_SPECIALMEMO> QC_SPECIALMEMO { get; set; }
        public virtual DbSet<QC_USERCHECKDETAIL> QC_USERCHECKDETAIL { get; set; }
        public virtual DbSet<QC_USERCHECKMASTER> QC_USERCHECKMASTER { get; set; }
        public virtual DbSet<QC_USERSCOREDETAIL> QC_USERSCOREDETAIL { get; set; }
        public virtual DbSet<QC_USERTVCHECK> QC_USERTVCHECK { get; set; }
        public virtual DbSet<RES_ACTIVITY> RES_ACTIVITY { get; set; }
        public virtual DbSet<RES_ACTIVITY_EXPORTLOG> RES_ACTIVITY_EXPORTLOG { get; set; }
        public virtual DbSet<RES_ALLCOTELOG> RES_ALLCOTELOG { get; set; }
        public virtual DbSet<RES_ALLCOTELOG_DETAIL> RES_ALLCOTELOG_DETAIL { get; set; }
        public virtual DbSet<RES_ALLCOTELOG_DETAIL_HIS> RES_ALLCOTELOG_DETAIL_HIS { get; set; }
        public virtual DbSet<RES_ALLCOTELOG_HIS> RES_ALLCOTELOG_HIS { get; set; }
        public virtual DbSet<RES_APPLY> RES_APPLY { get; set; }
        public virtual DbSet<RES_APPLY_HIS> RES_APPLY_HIS { get; set; }
        public virtual DbSet<RES_CALLOUTCUSTOMER> RES_CALLOUTCUSTOMER { get; set; }
        public virtual DbSet<RES_CUSTOMER> RES_CUSTOMER { get; set; }
        public virtual DbSet<RES_CUSTOMERDETAIL> RES_CUSTOMERDETAIL { get; set; }
        public virtual DbSet<RES_CUSTOMEREXTEND> RES_CUSTOMEREXTEND { get; set; }
        public virtual DbSet<RES_CUSTOMERFEEDBACK> RES_CUSTOMERFEEDBACK { get; set; }
        public virtual DbSet<RES_CUSTOMERUSER> RES_CUSTOMERUSER { get; set; }
        public virtual DbSet<RES_DISTRIBUTE> RES_DISTRIBUTE { get; set; }
        public virtual DbSet<RES_DISTRIBUTE_DETAIL> RES_DISTRIBUTE_DETAIL { get; set; }
        public virtual DbSet<RES_DISTRIBUTEDETAIL_HIS> RES_DISTRIBUTEDETAIL_HIS { get; set; }
        public virtual DbSet<RES_IMPORTRES> RES_IMPORTRES { get; set; }
        public virtual DbSet<RES_MYALLOCATERES> RES_MYALLOCATERES { get; set; }
        public virtual DbSet<RES_MYVALIDRES> RES_MYVALIDRES { get; set; }
        public virtual DbSet<RES_POOLLOG> RES_POOLLOG { get; set; }
        public virtual DbSet<RES_RESOURCECOSTS> RES_RESOURCECOSTS { get; set; }
        public virtual DbSet<RES_RESOURCEMOBILE> RES_RESOURCEMOBILE { get; set; }
        public virtual DbSet<RES_RESOURCETYPE> RES_RESOURCETYPE { get; set; }
        public virtual DbSet<RES_SALESGROUP> RES_SALESGROUP { get; set; }
        public virtual DbSet<RES_SALESGROUP_DETAIL> RES_SALESGROUP_DETAIL { get; set; }
        public virtual DbSet<RES_STRATEGYRESOURCETYPE> RES_STRATEGYRESOURCETYPE { get; set; }
        public virtual DbSet<RES_TOBEALLCOTED> RES_TOBEALLCOTED { get; set; }
        public virtual DbSet<RES_USERAPPLYMODULE> RES_USERAPPLYMODULE { get; set; }
        public virtual DbSet<RES_VIPCUSTOMER> RES_VIPCUSTOMER { get; set; }
        public virtual DbSet<RES_WEEKCHART> RES_WEEKCHART { get; set; }
        public virtual DbSet<SMS_ACCOUNT> SMS_ACCOUNT { get; set; }
        public virtual DbSet<SMS_BATCHMSG> SMS_BATCHMSG { get; set; }
        public virtual DbSet<SMS_BATCHMSGDETAIL> SMS_BATCHMSGDETAIL { get; set; }
        public virtual DbSet<SMS_BATCHMSGDETAIL_HIS> SMS_BATCHMSGDETAIL_HIS { get; set; }
        public virtual DbSet<SMS_BATCHMSGTEMPLATE> SMS_BATCHMSGTEMPLATE { get; set; }
        public virtual DbSet<SMS_FROMEMAIL> SMS_FROMEMAIL { get; set; }
        public virtual DbSet<SMS_MESSAGE> SMS_MESSAGE { get; set; }
        public virtual DbSet<SMS_MESSAGE_HIS> SMS_MESSAGE_HIS { get; set; }
        public virtual DbSet<SMS_MOBILEPOPULAR> SMS_MOBILEPOPULAR { get; set; }
        public virtual DbSet<SMS_MOBILEPOPULARDETAIL> SMS_MOBILEPOPULARDETAIL { get; set; }
        public virtual DbSet<SMS_MSGSUBTYPE> SMS_MSGSUBTYPE { get; set; }
        public virtual DbSet<SMS_MSGTEMPLATE> SMS_MSGTEMPLATE { get; set; }
        public virtual DbSet<SMS_MSGTYPE> SMS_MSGTYPE { get; set; }
        public virtual DbSet<SMS_MSGTYPE_CLIENT> SMS_MSGTYPE_CLIENT { get; set; }
        public virtual DbSet<SMS_SENDLOG> SMS_SENDLOG { get; set; }
        public virtual DbSet<SMS_USERVERIFYCODE> SMS_USERVERIFYCODE { get; set; }
        public virtual DbSet<SOFT_ACTIVE> SOFT_ACTIVE { get; set; }
        public virtual DbSet<SOFT_ACTIVEDETAIL> SOFT_ACTIVEDETAIL { get; set; }
        public virtual DbSet<SOFT_ACTIVEMODULE> SOFT_ACTIVEMODULE { get; set; }
        public virtual DbSet<SOFT_ACTIVEORDER> SOFT_ACTIVEORDER { get; set; }
        public virtual DbSet<SOFT_ACTIVEREVAPPLY> SOFT_ACTIVEREVAPPLY { get; set; }
        public virtual DbSet<SOFT_ALLOCATERESLOG> SOFT_ALLOCATERESLOG { get; set; }
        public virtual DbSet<SOFT_CUSTOMER> SOFT_CUSTOMER { get; set; }
        public virtual DbSet<SOFT_IMPORT_CUSTOMER> SOFT_IMPORT_CUSTOMER { get; set; }
        public virtual DbSet<SOFT_JUEJINACTIVITYCONFIG> SOFT_JUEJINACTIVITYCONFIG { get; set; }
        public virtual DbSet<SOFT_JUEJINRES> SOFT_JUEJINRES { get; set; }
        public virtual DbSet<SOFT_MODULE> SOFT_MODULE { get; set; }
        public virtual DbSet<SOFT_PRODUCT> SOFT_PRODUCT { get; set; }
        public virtual DbSet<SOFT_REMOTECODE> SOFT_REMOTECODE { get; set; }
        public virtual DbSet<SOFT_USER> SOFT_USER { get; set; }
        public virtual DbSet<WX_ACTIVEUSER> WX_ACTIVEUSER { get; set; }
        public virtual DbSet<WX_ALIVE> WX_ALIVE { get; set; }
        public virtual DbSet<WX_BIZINFO> WX_BIZINFO { get; set; }
        public virtual DbSet<WX_DBRECIVE> WX_DBRECIVE { get; set; }
        public virtual DbSet<WX_FILEPATH> WX_FILEPATH { get; set; }
        public virtual DbSet<WX_INNERUSERJOBNUM> WX_INNERUSERJOBNUM { get; set; }
        public virtual DbSet<WX_JOBBIZINFO> WX_JOBBIZINFO { get; set; }
        public virtual DbSet<WX_MESSAGE> WX_MESSAGE { get; set; }
        public virtual DbSet<WX_RCONTACT> WX_RCONTACT { get; set; }
        public virtual DbSet<WX_UINCONFIG> WX_UINCONFIG { get; set; }
        public virtual DbSet<WX_USERPERCENT> WX_USERPERCENT { get; set; }
        public virtual DbSet<WX_GROUPPERCENT> WX_GROUPPERCENT { get; set; }
        public virtual DbSet<WX_SETPERCENTLOG> WX_SETPERCENTLOG { get; set; }
        public virtual DbSet<CACHE_MEMOID_DELETE> CACHE_MEMOID_DELETE { get; set; }
        public virtual DbSet<CSVR_CALLOUTPARA> CSVR_CALLOUTPARA { get; set; }
        public virtual DbSet<IMP_RESIMPORTID> IMP_RESIMPORTID { get; set; }

        public virtual DbSet<EXP_RESIMPORTID> EXP_RESIMPORTID { get; set; }
        public virtual DbSet<RES_CUSTOMER_CSH> RES_CUSTOMER_CSH { get; set; }
        public virtual DbSet<RES_IMPORTRES_DETAIL> RES_IMPORTRES_DETAIL { get; set; }
        public virtual DbSet<RES_POOLLOG_HIS> RES_POOLLOG_HIS { get; set; }
        public virtual DbSet<RES_POOLLOGBAK_20151130> RES_POOLLOGBAK_20151130 { get; set; }
        public virtual DbSet<RES_RESOURCEMOBILE_BAK> RES_RESOURCEMOBILE_BAK { get; set; }
        public virtual DbSet<RES_RESOURCETYPE_20160121> RES_RESOURCETYPE_20160121 { get; set; }
        public virtual DbSet<SOFT_BIGPRODUCT> SOFT_BIGPRODUCT { get; set; }
        public virtual DbSet<SOFT_MODULE_TG> SOFT_MODULE_TG { get; set; }
        public virtual DbSet<SOFT_PRODUCTMODULE> SOFT_PRODUCTMODULE { get; set; }
        public virtual DbSet<RES_ALLOCATESTRATEGY> RES_ALLOCATESTRATEGY { get; set; }
        public virtual DbSet<VIEW_BAS_INNERUSER> VIEW_BAS_INNERUSER { get; set; }
        public virtual DbSet<VIEW_RES_DISTRIBUTE> VIEW_RES_DISTRIBUTE { get; set; }
        public virtual DbSet<WX_WORKACCOUNT> WX_WORKACCOUNT { get; set; }

        public virtual DbSet<WX_WORKACCOUNT_INIT> WX_WORKACCOUNT_INIT { get; set; }
        public virtual DbSet<WX_WORKACCOUNT_NOTE> WX_WORKACCOUNT_NOTE { get; set; }

        public virtual DbSet<WX_SZZYPRODUCT> WX_SZZYPRODUCT { get; set; }
        public virtual DbSet<WX_SZZYSUBPRODUCT> WX_SZZYSUBPRODUCT { get; set; }

        public virtual DbSet<WX_SZZYORDER> WX_SZZYORDER { get; set; }

        public virtual DbSet<WX_COMMISSIONRULE> WX_COMMISSIONRULE { get; set; }

        public virtual DbSet<WX_ALIVEIMEI> WX_ALIVEIMEI { get; set; }

        public virtual DbSet<WX_USERIMEI> WX_USERIMEI { get; set; }

        public virtual DbSet<WX_ZXREGISTERLOG> WX_ZXREGISTERLOG { get; set; }
        public virtual DbSet<WX_FRIENDSRELATION> WX_FRIENDSRELATION { get; set; }

        public virtual DbSet<WX_BALANCE_LOG> WX_BALANCE_LOG { get; set; }
        public virtual DbSet<WX_BALANCE> WX_BALANCE { get; set; }

        public virtual DbSet<BAS_NOTICE> BAS_NOTICE { get; set; }

        public virtual DbSet<WX_BALANCESALEUSER> WX_BALANCESALEUSER { get; set; }
        public virtual DbSet<WX_BALANCESALEUSERAUDIT> WX_BALANCESALEUSERAUDIT { get; set; }
        public virtual DbSet<WX_BALANCESALEGROUPER> WX_BALANCESALEGROUPER { get; set; }
        public virtual DbSet<WX_BALANCESALEGROUPERAUDIT> WX_BALANCESALEGROUPERAUDIT { get; set; }
        public virtual DbSet<WX_BALANCEAFTERSALEAUDIT> WX_BALANCEAFTERSALEAUDIT { get; set; }
        public virtual DbSet<WX_COMPLAINTATTENDANCE> WX_COMPLAINTATTENDANCE { get; set; }
        public virtual DbSet<WX_BONUSSALEUSER> WX_BONUSSALEUSER { get; set; }
        public virtual DbSet<WX_LASTMSGTIME> WX_LASTMSGTIME { get; set; }

        public virtual DbSet<WX_ARRIVALPAYLOG> WX_ARRIVALPAYLOG { get; set; }
        public virtual DbSet<WX_DBUPLOADLOG> WX_DBUPLOADLOG { get; set; }

        public virtual DbSet<WX_SZZYORDERUSERNAME> WX_SZZYORDERUSERNAME { get; set; }

        public virtual DbSet<WX_RESOURCECHECK> WX_RESOURCECHECK { get; set; }
        public virtual DbSet<WX_RESOURCECHECK_NOTE> WX_RESOURCECHECK_NOTE { get; set; }

        public virtual DbSet<WX_SYSTEMPAUSELOG> WX_SYSTEMPAUSELOG { get; set; }

        public virtual DbSet<WX_WORKACCOUNT_ONLINELOG> WX_WORKACCOUNT_ONLINELOG { get; set; }

        public virtual DbSet<RES_MOBILEQUERYLOG> RES_MOBILEQUERYLOG { get; set; }

        public virtual DbSet<WX_COMMUNICATION_DAY> WX_COMMUNICATION_DAY { get; set; }

        public virtual DbSet<WX_ATTENDANCE> WX_ATTENDANCE { get; set; }

        public virtual DbSet<L2_SOFT_BIGPRODUCT> L2_SOFT_BIGPRODUCT { get; set; }
        public virtual DbSet<L2_SOFT_MODULE> L2_SOFT_MODULE { get; set; }
        public virtual DbSet<L2_SOFT_ORDER> L2_SOFT_ORDER { get; set; }
        public virtual DbSet<L2_SOFT_PRODUCT> L2_SOFT_PRODUCT { get; set; }
        public virtual DbSet<L2_SOFT_PRODUCTMODULE> L2_SOFT_PRODUCTMODULE { get; set; }
        public virtual DbSet<L2_SOFT_REFUNDAPPLAY> L2_SOFT_REFUNDAPPLAY { get; set; }

        public virtual DbSet<WX_ORDEREXT> WX_ORDEREXT { get; set; }
        public virtual DbSet<WX_AFTERSALES> WX_AFTERSALES { get; set; }

        public virtual DbSet<WX_AFTERSALES_LOG> WX_AFTERSALES_LOG { get; set; }

        public virtual DbSet<QC_COMPLAIN_SERVICEMEMO> QC_COMPLAIN_SERVICEMEMO { get; set; }

        public virtual DbSet<WX_SZZYORDER_REFUND> WX_SZZYORDER_REFUND { get; set; }

        public virtual DbSet<WX_STOCKRECOMMEND> WX_STOCKRECOMMEND { get; set; }

        public virtual DbSet<BAS_FEEDBACK> BAS_FEEDBACK { get; set; }
        public virtual DbSet<RES_SALESGROUPPROMOTION> RES_SALESGROUPPROMOTION { get; set; }
        public virtual DbSet<RES_SALESGROUPPROMOTION_TAG> RES_SALESGROUPPROMOTION_TAG { get; set; }
        public virtual DbSet<RES_SALESGROUPPROMOTION_DETAIL> RES_SALESGROUPPROMOTION_DETAIL { get; set; }
        public virtual DbSet<RES_SALESGROUPPROMOTION_LOG> RES_SALESGROUPPROMOTION_LOG { get; set; }

        public virtual DbSet<WX_MESSAGECOMPLIANCE> WX_MESSAGECOMPLIANCE { get; set; }
        public virtual DbSet<WX_LEAVE> WX_LEAVE { get; set; }
        public virtual DbSet<BAS_COMPLIANCE> BAS_COMPLIANCE { get; set; }
        public virtual DbSet<WX_UNLINE_NOTICECONFIG> WX_UNLINE_NOTICECONFIG { get; set; }
        public virtual DbSet<WX_AFTERSALE_COMMISSION> WX_AFTERSALE_COMMISSION { get; set; }
        public virtual DbSet<BAS_ACTIONLOG> BAS_ACTIONLOG { get; set; }
        public virtual DbSet<BAS_ACTIONLOGCONFIG> BAS_ACTIONLOGCONFIG { get; set; }
        public virtual DbSet<WEAPP_USERINFO> WEAPP_USERINFO { get; set; }
        public virtual DbSet<WEAPP_FRIENDS> WEAPP_FRIENDS { get; set; }
        public virtual DbSet<WEAPP_SALEUSERS> WEAPP_SALEUSERS { get; set; }
        public virtual DbSet<WEAPP_GROUP> WEAPP_GROUP { get; set; }
        public virtual DbSet<WEAPP_USERGROUP> WEAPP_USERGROUP { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<WX_DBUPLOADLOG>()
              .Property(e => e.PKID)
              .HasPrecision(38, 0);

            modelBuilder.Entity<WX_DBUPLOADLOG>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_DBUPLOADLOG>()
                .Property(e => e.DBFILE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_DBUPLOADLOG>()
                .Property(e => e.PASSWORD)
                .IsUnicode(false);
            modelBuilder.Entity<WX_WORKACCOUNT>()
                 .Property(e => e.USERNAME)
                 .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.ALIAS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.CONREMARK)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.DOMAINLIST)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.NICKNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.PYINITIAL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.QUANPIN)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.SHOWHEAD)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.TYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.WEIBOFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.WEIBONICKNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.CONREMARKPYFULL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.CONREMARKPYSHORT)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.LVBUFF)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.VERFYFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.ENCRYPTUSERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.CHATROOMFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.DELETEFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.CONTACTLABELIDS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.RESID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.QRCODEURL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.ISVALID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT>()
                .Property(e => e.QUANTITY)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_BUSINESS>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_BUSINESSTYPE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_BUSINESSTYPE>()
                .Property(e => e.BUSINESSCODE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_BUSINESSTYPE>()
                .Property(e => e.BUSINESSNAME)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_BUSINESSTYPE>()
                .Property(e => e.ISSHOW)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_CITY>()
                .Property(e => e.ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_CITY>()
                .Property(e => e.PROVINCEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_COMPANY>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_COMPANY>()
                .Property(e => e.PARENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_COMPANY>()
                .Property(e => e.COMPANYCODE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_COMPANY>()
                .Property(e => e.BUSINESSVALUE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_COMPANY>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_COMPANY>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_COMPANY>()
                .Property(e => e.SYSTEMCODE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_COMPANYCAMPAIN>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_COMPANYCAMPAIN>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_COMPANYCAMPAIN>()
                .Property(e => e.CAMPAINID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_COMTYPE>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_COMTYPE>()
                .Property(e => e.TYPENAME)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_COMTYPE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_DAILYMEMU>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_DAILYMEMU>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_DAILYMEMU>()
                .Property(e => e.MENUID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_DAILYMEMU>()
                .Property(e => e.SORTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_DAILYMEMU>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);



            modelBuilder.Entity<BAS_GROUPLEADER>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_GROUPLEADER>()
                .Property(e => e.INNERGROUPID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_GROUPLEADER>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_GROUPLEADER>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_GROUPLEADER>()
                .Property(e => e.LEADERTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERDEPARTMENT>()
                .Property(e => e.DEPTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERDEPARTMENT>()
                .Property(e => e.PARENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERDEPARTMENT>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERDEPARTMENT>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERDEPARTMENT>()
                .Property(e => e.INNERDEPTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_INNERGROUP>()
                .Property(e => e.GID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERGROUP>()
                .Property(e => e.SALEDEPTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERGROUP>()
                .Property(e => e.DEPTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERGROUP>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERGROUP>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER>()
                .Property(e => e.GENDER)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<BAS_INNERUSER>()
                .Property(e => e.PASSWORD)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_INNERUSER>()
                .Property(e => e.DISMISSTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER>()
                .HasOptional(e => e.BAS_INNERUSERGROUP)
                .WithRequired(e => e.BAS_INNERUSER);

            modelBuilder.Entity<BAS_INNERUSER>()
                .HasMany(e => e.BAS_INNERUSERROLE)
                .WithRequired(e => e.BAS_INNERUSER)
                .HasForeignKey(e => e.INNERUSERID)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<BAS_INNERUSER_EXT>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER_EXT_LOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER_EXT_LOG>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER_EXT_LOG>()
                .Property(e => e.EXTENDTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER_EXT_LOG>()
                .Property(e => e.NEWSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER_EXT_LOG>()
                .Property(e => e.OLDSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSER_EXT_LOG>()
                .Property(e => e.OPTIONUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERGROUP>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERGROUP>()
                .Property(e => e.DEPTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERGROUP>()
                .Property(e => e.GID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERGROUP>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERGROUP>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERINFORMATIONTIPS>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERINFORMATIONTIPS>()
                .Property(e => e.GROUPNAME)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_INNERUSERINFORMATIONTIPS>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERINFORMATIONTIPS>()
                .Property(e => e.TRADECODE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_INNERUSERINFORMATIONTIPS>()
                .Property(e => e.INFORMATIONTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERROLE>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERROLE>()
                .Property(e => e.ROLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERROLE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERROLE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERSALT>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERSALT>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERSALT>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_INNERUSERSALT>()
                .Property(e => e.PWDSALT)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_INNERUSERSALT>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_LEFTMEMU>()
                .Property(e => e.MENUID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_LEFTMEMU>()
                .Property(e => e.MODULEMENUID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_LEFTMEMU>()
                .Property(e => e.URL)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_LEFTMEMU>()
                .Property(e => e.RIGHTID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<BAS_LEFTMEMU>()
                .Property(e => e.PARENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_LEFTMEMU>()
                .Property(e => e.SORTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_LEFTMEMU>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_LOGINLOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_LOGINLOG>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_LOGINLOG>()
                .Property(e => e.LOGINEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_LOGINLOG>()
                .Property(e => e.LOGINIP)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_LOGINLOG>()
                .Property(e => e.TELNUM)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_MOBILEAREA>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_MODULEMENU>()
                .Property(e => e.MODULEMENUID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_MODULEMENU>()
                .Property(e => e.RIGHTID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<BAS_MODULEMENU>()
                .Property(e => e.IMAGEURL)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_MODULEMENU>()
                .Property(e => e.SORTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_MODULEMENU>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_OPERATIONLOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_OPERATIONLOG>()
                .Property(e => e.OPUSER_ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_OPERATIONLOG>()
                .Property(e => e.OPUSER_EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_OPERATIONLOG>()
                .Property(e => e.REQUESTURL)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_OPERATIONLOG>()
                .Property(e => e.CLIENTIP)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_OPERATIONLOG>()
                .Property(e => e.OPREMARK)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.PARAKEY)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.GROUPID)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.PARAVALUE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.PARATYPE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.REMARK)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.EDITFORM)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.PARANAME)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.DEPTCDOE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETER>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_PARAMETERGROUP>()
                .Property(e => e.GROUPID)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETERGROUP>()
                .Property(e => e.GROUPNAME)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PARAMETERGROUP>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_PROCEXECUTE_LOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_PROCEXECUTE_LOG>()
                .Property(e => e.STATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_PROCEXECUTE_LOG>()
                .Property(e => e.PROCTYPE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_PROVINCE>()
                .Property(e => e.ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_PROVINCE>()
                .Property(e => e.NAME)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_RIGHT>()
                .Property(e => e.RIGHTID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<BAS_RIGHT>()
                .Property(e => e.SORTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_RIGHT>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_RIGHT>()
                .Property(e => e.GROUPID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_RIGHT>()
                .HasMany(e => e.BAS_ROLERIGHTRESOURCE)
                .WithRequired(e => e.BAS_RIGHT)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<BAS_RIGHT_TOOLBUTTON>()
                .Property(e => e.RIGHTID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<BAS_RIGHT_TOOLBUTTON>()
                .Property(e => e.BUTTONID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_RIGHTGROUP>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_RIGHTGROUP>()
                .Property(e => e.PARENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_RIGHTGROUP>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_RIGHTGROUP>()
                .HasMany(e => e.BAS_RIGHT)
                .WithOptional(e => e.BAS_RIGHTGROUP)
                .HasForeignKey(e => e.GROUPID);

            modelBuilder.Entity<BAS_ROLE>()
                .Property(e => e.ROLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROLE>()
                .Property(e => e.SORTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROLE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROLE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROLE>()
                .HasMany(e => e.BAS_ROLERIGHTRESOURCE)
                .WithRequired(e => e.BAS_ROLE)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<BAS_ROLERIGHTRESOURCE>()
                .Property(e => e.ROLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROLERIGHTRESOURCE>()
                .Property(e => e.RIGHTID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<BAS_ROLERIGHTRESOURCE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROLERIGHTRESOURCE>()
                .Property(e => e.TOOLBARVALUE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROOM>()
                .Property(e => e.ROOMID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROOM>()
                .Property(e => e.ROOMCODE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_ROOM>()
                .Property(e => e.ROOMTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROOM>()
                .Property(e => e.ROOMMARKETTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROOM>()
                .Property(e => e.ISSHOW)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROOM>()
                .Property(e => e.ISDELETED)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROOM>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROOM>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_ROOM>()
                .Property(e => e.SORTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_SALESDEPARTMENT>()
                .Property(e => e.SALEDEPTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_SALESDEPARTMENT>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_SALESDEPARTMENT>()
                .Property(e => e.SALEDEPTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<BAS_SALESDEPARTMENT>()
                .Property(e => e.LINKNAME)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_SALESDEPARTMENT>()
                .Property(e => e.AREACODE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_SALESDEPARTMENT>()
                .Property(e => e.PHONE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_SALESDEPARTMENT>()
                .Property(e => e.CREATIONBY)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_SALESDEPARTMENT>()
                .Property(e => e.UPDATEBY)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_SUBCOMTYPE>()
                .Property(e => e.SUBTYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_SUBCOMTYPE>()
                .Property(e => e.SUBTYPENAME)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_SUBCOMTYPE>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_SUBCOMTYPE>()
                .Property(e => e.REMARK)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_SUBCOMTYPE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_SUBCOMTYPE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_SUBCOMTYPE>()
                .Property(e => e.EDITFORM)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_USERGROUPCHANGELOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_USERGROUPCHANGELOG>()
                .Property(e => e.NEWGROUPID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_USERGROUPCHANGELOG>()
                .Property(e => e.OLDGROUPID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_USERGROUPCHANGELOG>()
                .Property(e => e.SALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_USERGROUPCHANGELOG>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_ORD_MEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_ORD_MEMO>()
                .Property(e => e.MTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_ORD_MEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_ORD_MEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_ORD_MEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CACHE_ORD_MEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_ORD_MEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_ORD_MEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_ORD_MEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_QC_ORDMEMO>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_QC_ORDMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_QC_ORDMEMO>()
                .Property(e => e.MTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_QC_ORDMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_QC_ORDMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_QC_ORDMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CACHE_QC_ORDMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_QC_ORDMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_QC_ORDMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_QC_ORDMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_RES_POOLLOG>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_RES_POOLLOG>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CACHE_RES_POOLLOG>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_RES_POOLLOG>()
                .Property(e => e.ACTIVITYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_RES_POOLLOG>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_RES_POOLLOG>()
                .Property(e => e.APPLYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_RES_POOLLOG>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<CACHE_RES_POOLLOG>()
                .Property(e => e.DATATYPE)
                .IsUnicode(false);

            modelBuilder.Entity<CACHE_RES_RESOURCE_COUNT>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_APPLYPRIMARYNUMBER>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_APPLYPRIMARYNUMBER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_APPLYPRIMARYNUMBER>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_APPLYPRIMARYNUMBER>()
                .Property(e => e.CHECKSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_APPLYPRIMARYNUMBER>()
                .Property(e => e.CHECKUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_APPLYVIP>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_APPLYVIP>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_APPLYVIP>()
                .Property(e => e.ISLOCAL)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_APPLYVIP>()
                .Property(e => e.STATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_APPLYVIP>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_APPLYVIP>()
                .Property(e => e.OPERATORID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_APPLYVIP>()
                .Property(e => e.PHONE)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_BLACKNUMBER>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_BLACKNUMBER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_BLACKNUMBER>()
                .Property(e => e.BLACKTYPE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_BLACKNUMBER>()
                .Property(e => e.CREATEUSRE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLDATAREPORT>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLDATAREPORT>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLDATAREPORT>()
                .Property(e => e.TOTAL_COUT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLDATAREPORT>()
                .Property(e => e.TIMELEN_COUT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLDATAREPORT>()
                .Property(e => e.TOTAL_CIN)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLDATAREPORT>()
                .Property(e => e.TIMELEN_CIN)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLDATAREPORT>()
                .Property(e => e.TOTAL_COUNT_MOBILE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLDATAREPORT>()
                .Property(e => e.TOTAL_UN_COUNT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLINLOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLINLOG>()
                .Property(e => e.SRID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLINLOG>()
                .Property(e => e.CALLEDNUMBER)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLINLOG>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLINLOG>()
                .Property(e => e.CALLSTATE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLINLOG>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.RECORDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.SERVERID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.SERVICENUMBER)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.TELNUMBERLAST4)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.TIMELENGTH)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.CALLTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.COID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD>()
                .Property(e => e.ISTRAN)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.RECORDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.SERVERID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.SERVICENUMBER)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.TELNUMBERLAST4)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.TIMELENGTH)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.CALLTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.COID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD_HIS>()
                .Property(e => e.ISTRAN)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.RECORDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.SERVERID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.SERVICENUMBER)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.TELNUMBERLAST4)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.TIMELENGTH)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.CALLTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.COID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORD2>()
                .Property(e => e.ISTRAN)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORDDAYSTATISTICS>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORDDAYSTATISTICS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.RECORDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.SERVERID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.SERVICENUMBER)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.TELNUMBERLAST4)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.TIMELENGTH)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.CALLTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.COID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLRECORDUN>()
                .Property(e => e.DISPOSITION)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLSTATIS>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLSTATIS>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLSTATIS>()
                .Property(e => e.SATISFACTION1)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLSTATIS>()
                .Property(e => e.SATISFACTION2)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLSTATIS>()
                .Property(e => e.SATISFACTION3)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLSTATIS>()
                .Property(e => e.SATISFACTION4)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLSTATISDETAIL>()
                .Property(e => e.PKID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLSTATISDETAIL>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLSTATISDETAIL>()
                .Property(e => e.SATISFACTION)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLSTATISDETAIL>()
                .Property(e => e.SESSIONID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_FAVORITECUSTOMER>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_FAVORITECUSTOMER>()
                .Property(e => e.SALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_FAVORITECUSTOMER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_FAVORITECUSTOMER>()
                .Property(e => e.PARAKEY)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.RECORDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.SERVICENUMBER)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.TELNUMBERLAST4)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.TIMELENGTH)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.SERVERID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_HGRECORD>()
                .Property(e => e.RECORDTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_IDMAP>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_IDMAP>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_IDMAP>()
                .Property(e => e.CUSTOMERID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_MSGOPENACCOUNT>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_MSGOPENACCOUNT>()
                .Property(e => e.SALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_MSGOPENACCOUNT>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_MSGOPENACCOUNT>()
                .Property(e => e.MSGTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.RECORDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.SERVERID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.SERVICENUMBER)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.TELNUMBERLAST4)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.TIMELENGTH)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.RECORDSHAREDTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.RECORDTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.BIGTYPE)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.SUBTYPE)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_RECORDSHARED>()
                .Property(e => e.SALESUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RECORDTYPE>()
                .Property(e => e.ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RELATIONCUSTOMER>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_RELATIONCUSTOMER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_RELATIONCUSTOMER>()
                .Property(e => e.RELATIONRESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_RELATIONCUSTOMER>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.RECORDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.SERVERID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.SERVICENUMBER)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.TELNUMBERLAST4)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.TIMELENGTH)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.CALLTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.COID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORD>()
                .Property(e => e.ISTRAN)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.RECORDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.SERVERID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.SERVICENUMBER)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.TELNUMBERLAST4)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.TIMELENGTH)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.CALLTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.SALESEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.COID)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODAYRECORDUN>()
                .Property(e => e.DISPOSITION)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODOITEM>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODOITEM>()
                .Property(e => e.SENDEDUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODOITEM>()
                .Property(e => e.RECEIVEDUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODOITEM>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_TODOITEM>()
                .Property(e => e.DOSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODOITEM>()
                .Property(e => e.DOUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODOSTATUS>()
                .Property(e => e.STATUSCODE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_TODOSTATUS>()
                .Property(e => e.STATUSNAME)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLY>()
                .Property(e => e.UNITEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLY>()
                .Property(e => e.RESID1)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLY>()
                .Property(e => e.RESID2)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLY>()
                .Property(e => e.APPLYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLY>()
                .Property(e => e.AUDITID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLY>()
                .Property(e => e.STATE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLY>()
                .HasMany(e => e.CSVR_UNITECUSTOMERAPPLYDETAIL)
                .WithRequired(e => e.CSVR_UNITECUSTOMERAPPLY)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLYDETAIL>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLYDETAIL>()
                .Property(e => e.UNITEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLYDETAIL>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLYDETAIL>()
                .Property(e => e.OLDCUSTOMERID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_UNITECUSTOMERAPPLYDETAIL>()
                .Property(e => e.NEWCUSTOMERID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<HIS_BAS_LOGINLOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_BAS_LOGINLOG>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_BAS_LOGINLOG>()
                .Property(e => e.LOGINEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_BAS_LOGINLOG>()
                .Property(e => e.LOGINIP)
                .IsUnicode(false);

            modelBuilder.Entity<HIS_BAS_LOGINLOG>()
                .Property(e => e.TELNUM)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_BAS_OPERATIONLOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_BAS_OPERATIONLOG>()
                .Property(e => e.OPUSER_ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_BAS_OPERATIONLOG>()
                .Property(e => e.OPUSER_EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_BAS_OPERATIONLOG>()
                .Property(e => e.REQUESTURL)
                .IsUnicode(false);

            modelBuilder.Entity<HIS_BAS_OPERATIONLOG>()
                .Property(e => e.CLIENTIP)
                .IsUnicode(false);

            modelBuilder.Entity<HIS_BAS_OPERATIONLOG>()
                .Property(e => e.OPREMARK)
                .IsUnicode(false);

            modelBuilder.Entity<HIS_ISVR_INTERFACECALLLOG>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ISVR_INTERFACECALLLOG>()
                .Property(e => e.CLIENTIP)
                .IsUnicode(false);

            modelBuilder.Entity<HIS_ISVR_INTERFACECALLLOG>()
                .Property(e => e.CLIENTURL)
                .IsUnicode(false);

            modelBuilder.Entity<HIS_ISVR_INTERFACECALLLOG>()
                .Property(e => e.CLIENTKEY)
                .IsUnicode(false);

            modelBuilder.Entity<HIS_ORD_MEMOCONTENT>()
                .Property(e => e.CONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_PURPOSEMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_PURPOSEMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_PURPOSEMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_PURPOSEMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<HIS_ORD_PURPOSEMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_PURPOSEMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_PURPOSEMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_PURPOSEMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SALEMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SALEMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SALEMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SALEMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<HIS_ORD_SALEMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SALEMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SALEMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SALEMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SERVICEMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SERVICEMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SERVICEMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SERVICEMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<HIS_ORD_SERVICEMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SERVICEMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SERVICEMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SERVICEMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SPECIALMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SPECIALMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SPECIALMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SPECIALMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<HIS_ORD_SPECIALMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SPECIALMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SPECIALMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_ORD_SPECIALMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_BATCHMSG>()
                .Property(e => e.BATCHID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_BATCHMSG>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<HIS_SMS_BATCHMSG>()
                .Property(e => e.SUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_BATCHMSG>()
                .Property(e => e.CLIENTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<HIS_SMS_BATCHMSG>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_BATCHMSGDETAIL_HIS>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_BATCHMSGDETAIL_HIS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<HIS_SMS_BATCHMSGDETAIL_HIS>()
                .Property(e => e.BATCHID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_BATCHMSGDETAIL_HIS>()
                .Property(e => e.SENDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_MESSAGE_HIS>()
                .Property(e => e.MESSAGEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_MESSAGE_HIS>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<HIS_SMS_MESSAGE_HIS>()
                .Property(e => e.SUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_MESSAGE_HIS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<HIS_SMS_MESSAGE_HIS>()
                .Property(e => e.CLIENTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<HIS_SMS_MESSAGE_HIS>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_MESSAGE_HIS>()
                .Property(e => e.SENDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_SENDLOG>()
                .Property(e => e.SENDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<HIS_SMS_SENDLOG>()
                .Property(e => e.CLIENTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<HIS_SMS_SENDLOG>()
                .Property(e => e.MSGSOURCEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ISVR_INTERFACECALLLOG>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ISVR_INTERFACECALLLOG>()
                .Property(e => e.CLIENTIP)
                .IsUnicode(false);

            modelBuilder.Entity<ISVR_INTERFACECALLLOG>()
                .Property(e => e.CLIENTURL)
                .IsUnicode(false);

            modelBuilder.Entity<ISVR_INTERFACECALLLOG>()
                .Property(e => e.CLIENTKEY)
                .IsUnicode(false);

            modelBuilder.Entity<ORD_HEGUIMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_HEGUIMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_HEGUIMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_HEGUIMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<ORD_HEGUIMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_HEGUIMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_HEGUIMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_HEGUIMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_HEGUIMEMO>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<ORD_HEGUIMEMO>()
                .Property(e => e.ISDOWNED)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOCONTENT>()
                .Property(e => e.CONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOSTYLE>()
                .Property(e => e.STYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOSTYLE>()
                .Property(e => e.STYLECODE)
                .IsUnicode(false);

            modelBuilder.Entity<ORD_MEMOSUBTYPE>()
                .Property(e => e.SUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOSUBTYPE>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOSUBTYPE>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOSUBTYPE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOSUBTYPE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOSUBTYPE>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<ORD_MEMOTYPE>()
                .Property(e => e.TYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOTYPE>()
                .Property(e => e.MEMO_TYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOTYPE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOTYPE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_MEMOTYPE>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<ORD_PURPOSEMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_PURPOSEMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_PURPOSEMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_PURPOSEMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<ORD_PURPOSEMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_PURPOSEMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_PURPOSEMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_PURPOSEMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<ORD_SALEMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO_HIS>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO_HIS>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO_HIS>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO_HIS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<ORD_SALEMEMO_HIS>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO_HIS>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO_HIS>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SALEMEMO_HIS>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SERVICEMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SERVICEMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SERVICEMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SERVICEMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<ORD_SERVICEMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SERVICEMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SERVICEMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SERVICEMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SPECIALMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SPECIALMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SPECIALMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SPECIALMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<ORD_SPECIALMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SPECIALMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SPECIALMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<ORD_SPECIALMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BAS_INNERUSER>()
                .Property(e => e.RID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BAS_INNERUSER>()
                .Property(e => e.DEPTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<QC_BAS_INNERUSER>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BAS_INNERUSER>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BAS_INNERUSER>()
                .Property(e => e.GENDER)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<QC_BAS_INNERUSER>()
                .Property(e => e.PASSWORD)
                .IsUnicode(false);

            modelBuilder.Entity<QC_BAS_INNERUSER>()
                .Property(e => e.DISMISSTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BAS_INNERUSER>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BAS_INNERUSER>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BASEUSERSCORE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BASEUSERSCORE>()
                .Property(e => e.SCORENO)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BASEUSERSCORE>()
                .Property(e => e.SCOREDIR)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BASEUSERSCORE>()
                .Property(e => e.USERSCORE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BASEUSERSCORE>()
                .Property(e => e.USERSCOREAMT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BASEUSERSCORE>()
                .Property(e => e.SCORELEVEL)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BASEUSERSCORE>()
                .Property(e => e.GROUPERSCORE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BASEUSERSCORE>()
                .Property(e => e.GROUPERSCOREAMT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_BASEUSERSCORE>()
                .Property(e => e.ISSHOW)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_COMPLAINTDICT>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_COMPLAINTDICT>()
                .Property(e => e.DICTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_COMPLAINTDICT>()
                .Property(e => e.DICTVALUE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_COMPLAINTDICT>()
                .Property(e => e.ORD)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.RESID)
                .IsUnicode(false);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.SALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.STATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.FROMTYPE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.COMPLAINLEVEL)
                .IsUnicode(false);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.SERVERID)
                .IsUnicode(false);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.RECORDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.TRADECODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.DEPTAUDITPKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_CUSTOMERCOMPLAIN>()
                .Property(e => e.COMPLIANGUID)
                .IsUnicode(false);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.USERSCOREID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.DEPTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.GROUPERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.GROUPEREID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.INNERUSERGROUPID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.INNERUSEREID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.STATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.SCORENO)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.SCOREDIR)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_GROUPERSCOREDETAIL>()
                .Property(e => e.TRADECODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_MEMOCONTENT>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_MEMOCONTENT>()
                .Property(e => e.CONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_MEMOCONTENT>()
                .Property(e => e.DEPTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.DEPTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.MTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_ORDMEMO>()
                .Property(e => e.STRCONTENT)
                .IsUnicode(false);

            modelBuilder.Entity<QC_PURPOSEMEMO>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_PURPOSEMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_PURPOSEMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_PURPOSEMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_PURPOSEMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<QC_PURPOSEMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_PURPOSEMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_PURPOSEMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_PURPOSEMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_PURPOSEMEMO>()
                .Property(e => e.DEPTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_QUALITYTYPE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_QUALITYTYPE>()
                .Property(e => e.TYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SALEMEMO>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SALEMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SALEMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SALEMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SALEMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<QC_SALEMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SALEMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SALEMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SALEMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SALEMEMO>()
                .Property(e => e.DEPTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_SERVICEMEMO>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SERVICEMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SERVICEMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SERVICEMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SERVICEMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<QC_SERVICEMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SERVICEMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SERVICEMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SERVICEMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SERVICEMEMO>()
                .Property(e => e.DEPTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_SPECIALMEMO>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SPECIALMEMO>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SPECIALMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SPECIALMEMO>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SPECIALMEMO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<QC_SPECIALMEMO>()
                .Property(e => e.MEMOSTYLEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SPECIALMEMO>()
                .Property(e => e.MEMOTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SPECIALMEMO>()
                .Property(e => e.MEMOSUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SPECIALMEMO>()
                .Property(e => e.BUSINESSID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_SPECIALMEMO>()
                .Property(e => e.DEPTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.DETAILID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.MASTERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.DEPTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.GROUPID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.USERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.QUALITYTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.CHECKEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.QUALITYSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.QUALITYMEMO)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.QUALITYRUMOR)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERCHECKDETAIL>()
                .Property(e => e.QUALITYADVISE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERCHECKMASTER>()
                .Property(e => e.MASTERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKMASTER>()
                .Property(e => e.DEPTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERCHECKMASTER>()
                .Property(e => e.USERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKMASTER>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKMASTER>()
                .Property(e => e.QUALITYTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKMASTER>()
                .Property(e => e.QUALITYSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERCHECKMASTER>()
                .Property(e => e.CHECKEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERSCOREDETAIL>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERSCOREDETAIL>()
                .Property(e => e.DEPTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERSCOREDETAIL>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERSCOREDETAIL>()
                .Property(e => e.INNERUSEREID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERSCOREDETAIL>()
                .Property(e => e.INNERUSERGROUPID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERSCOREDETAIL>()
                .Property(e => e.STATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERSCOREDETAIL>()
                .Property(e => e.SCORENO)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERSCOREDETAIL>()
                .Property(e => e.SCOREDIR)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERSCOREDETAIL>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERSCOREDETAIL>()
                .Property(e => e.TRADECODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.MASTERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.DEPTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.GROUPID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.GROUPNAME)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.USERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.SALENAME)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.QUALITYTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.TVID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.CHECKEID)
                .IsUnicode(false);

            modelBuilder.Entity<QC_USERTVCHECK>()
                .Property(e => e.QUALITYSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ACTIVITY>()
                .Property(e => e.ACTIVITYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ACTIVITY>()
                .Property(e => e.ACTIVITYCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_ACTIVITY>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_ACTIVITY>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ACTIVITY>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ACTIVITY>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ACTIVITY>()
                .Property(e => e.ACTIVITYADDR)
                .IsUnicode(false);

            modelBuilder.Entity<RES_ACTIVITY_EXPORTLOG>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ACTIVITY_EXPORTLOG>()
                .Property(e => e.SOURCEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ACTIVITY_EXPORTLOG>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG>()
                .Property(e => e.STRATEGYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG>()
                .Property(e => e.DISNUMBER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL>()
                .Property(e => e.TURNING_ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL>()
                .Property(e => e.SALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL>()
                .Property(e => e.APPLYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL_HIS>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL_HIS>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL_HIS>()
                .Property(e => e.TURNING_ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL_HIS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_ALLCOTELOG_DETAIL_HIS>()
                .Property(e => e.SALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_HIS>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_HIS>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_HIS>()
                .Property(e => e.STRATEGYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLCOTELOG_HIS>()
                .Property(e => e.DISNUMBER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.JSONDATA)
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.JSONTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.STATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.MOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.DATATYPE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.ENMOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.ERR_COUNT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_APPLY>()
                .Property(e => e.ERR_STR)
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY_HIS>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_APPLY_HIS>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY_HIS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY_HIS>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY_HIS>()
                .Property(e => e.JSONDATA)
                .IsUnicode(false);

            modelBuilder.Entity<RES_APPLY_HIS>()
                .Property(e => e.JSONTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_APPLY_HIS>()
                .Property(e => e.STATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_APPLY_HIS>()
                .Property(e => e.DATATYPE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CALLOUTCUSTOMER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CALLOUTCUSTOMER>()
                .Property(e => e.CALLOUTTYPE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMER>()
                .Property(e => e.CUSTOMERID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMER>()
                .Property(e => e.CUSTOMERFROM)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMER>()
                .Property(e => e.LASTNUM3)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMER>()
                .HasOptional(e => e.RES_CUSTOMERDETAIL)
                .WithRequired(e => e.RES_CUSTOMER);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.CACCOUNT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.EMAIL)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.GENDER)
                .IsFixedLength();

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.PROVINCEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.CITYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.CUSTOMERTYPEID)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.AMOUNTTYPEID)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.JOBTYPEID)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.OPERATIONTYPE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.MSN)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.QQ)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.FAX)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.CUSTOMERFROMBIG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMERDETAIL>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMEREXTEND>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMEREXTEND>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMEREXTEND>()
                .Property(e => e.CUSTOMEREXTENDTYPEID)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMEREXTEND>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMEREXTEND>()
                .Property(e => e.CUSTOMEREXTENDSUBTYPEID)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMEREXTEND>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.CUSTOMERID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.CUSTOMERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.MOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.GENDER)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.AGELEVEL)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.PROVINCEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.CITYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.INVESTAGE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.INVESTPREFERENCE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.ISQUALIFIEDINVESTOR)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.ISINVESTYD)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.FINANCINGVOLUME)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.PREDICTDEADLINE)
                .HasPrecision(18, 4);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.EQUITYPRODUCT)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.MAXDEFICIT)
                .HasPrecision(18, 4);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.EMAIL)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.REMARK)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERFEEDBACK>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMERUSER>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_CUSTOMERUSER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMERUSER>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<RES_DISTRIBUTE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_DISTRIBUTE>()
                .Property(e => e.PICI)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_DISTRIBUTE>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_DISTRIBUTE>()
                .Property(e => e.ACTIVITYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_DISTRIBUTE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_DISTRIBUTE_DETAIL>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_DISTRIBUTE_DETAIL>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_DISTRIBUTE_DETAIL>()
                .Property(e => e.DISTRIBUTEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_DISTRIBUTE_DETAIL>()
                .Property(e => e.SALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_DISTRIBUTEDETAIL_HIS>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_DISTRIBUTEDETAIL_HIS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_DISTRIBUTEDETAIL_HIS>()
                .Property(e => e.DISTRIBUTEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_DISTRIBUTEDETAIL_HIS>()
                .Property(e => e.SALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_IMPORTRES>()
                .Property(e => e.IMPORTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_IMPORTRES>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_IMPORTRES>()
                .Property(e => e.ACTIVITYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_IMPORTRES>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_IMPORTRES>()
                .Property(e => e.OPTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_IMPORTRES>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYALLOCATERES>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYALLOCATERES>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYALLOCATERES>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_MYALLOCATERES>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_MYALLOCATERES>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYALLOCATERES>()
                .Property(e => e.DISUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYALLOCATERES>()
                .Property(e => e.DIS_TIMES)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYALLOCATERES>()
                .Property(e => e.TURNING_ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYVALIDRES>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYVALIDRES>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYVALIDRES>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_MYVALIDRES>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_MYVALIDRES>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYVALIDRES>()
                .Property(e => e.DISUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYVALIDRES>()
                .Property(e => e.DIS_TIMES)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MYVALIDRES>()
                .Property(e => e.TURNING_ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_POOLLOG>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG>()
                .Property(e => e.ACTIVITYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG>()
                .Property(e => e.APPLYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_POOLLOG>()
                .Property(e => e.DATATYPE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCECOSTS>()
                .Property(e => e.RESOURCEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCECOSTS>()
                .Property(e => e.WEEKED)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCECOSTS>()
                .Property(e => e.AMOUNT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCECOSTS>()
                .Property(e => e.PAPER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCECOSTS>()
                .Property(e => e.ACTUAL)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCECOSTS>()
                .Property(e => e.WEEKRESOURCE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCECOSTS>()
                .Property(e => e.ACTUALCOST)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCEMOBILE>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCEMOBILE>()
                .Property(e => e.MOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCEMOBILE>()
                .Property(e => e.ISMOBILE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCETYPE>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCETYPE>()
                .Property(e => e.RESTYPECODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCETYPE>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCETYPE>()
                .Property(e => e.BUSINESSCODE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCETYPE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCETYPE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCETYPE>()
                .Property(e => e.ATTRIBUTE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_SALESGROUP>()
                .Property(e => e.GROUPID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_SALESGROUP>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_STRATEGYRESOURCETYPE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_STRATEGYRESOURCETYPE>()
                .Property(e => e.STRATEGYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_STRATEGYRESOURCETYPE>()
                .Property(e => e.RESOURCETYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_STRATEGYRESOURCETYPE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_TOBEALLCOTED>()
                .Property(e => e.TURNING_ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_TOBEALLCOTED>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_TOBEALLCOTED>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_TOBEALLCOTED>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_TOBEALLCOTED>()
                .Property(e => e.APPLYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_TOBEALLCOTED>()
                .Property(e => e.DIS_NUM)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_USERAPPLYMODULE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_USERAPPLYMODULE>()
                .Property(e => e.USERCARDNO)
                .IsUnicode(false);

            modelBuilder.Entity<RES_USERAPPLYMODULE>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<RES_USERAPPLYMODULE>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_USERAPPLYMODULE>()
                .Property(e => e.MODULEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_USERAPPLYMODULE>()
                .Property(e => e.CUSTOMERFROM)
                .IsUnicode(false);

            modelBuilder.Entity<RES_VIPCUSTOMER>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_VIPCUSTOMER>()
                .Property(e => e.MOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_VIPCUSTOMER>()
                .Property(e => e.SCHEDULESTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_VIPCUSTOMER>()
                .Property(e => e.REASON)
                .IsUnicode(false);

            modelBuilder.Entity<RES_VIPCUSTOMER>()
                .Property(e => e.RESID)
                .IsUnicode(false);

            modelBuilder.Entity<RES_WEEKCHART>()
                .Property(e => e.WEEKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_WEEKCHART>()
                .Property(e => e.WEEKNUM)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_ACCOUNT>()
                .Property(e => e.CLIENTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_ACCOUNT>()
                .Property(e => e.SORTNO)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_ACCOUNT>()
                .Property(e => e.SMSSP_CODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_ACCOUNT>()
                .Property(e => e.SMSACCOUNT)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_ACCOUNT>()
                .Property(e => e.SMSPASSWORD)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_ACCOUNT>()
                .Property(e => e.REMARK)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_ACCOUNT>()
                .Property(e => e.EXTINFO1)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_ACCOUNT>()
                .Property(e => e.EXTINFO2)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_ACCOUNT>()
                .Property(e => e.EXTINFO3)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_ACCOUNT>()
                .HasMany(e => e.SMS_MSGTYPE_CLIENT)
                .WithRequired(e => e.SMS_ACCOUNT)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<SMS_BATCHMSG>()
                .Property(e => e.BATCHID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSG>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_BATCHMSG>()
                .Property(e => e.SUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSG>()
                .Property(e => e.CLIENTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_BATCHMSG>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSGDETAIL>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSGDETAIL>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_BATCHMSGDETAIL>()
                .Property(e => e.BATCHID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSGDETAIL_HIS>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSGDETAIL_HIS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_BATCHMSGDETAIL_HIS>()
                .Property(e => e.BATCHID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSGDETAIL_HIS>()
                .Property(e => e.SENDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSGTEMPLATE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSGTEMPLATE>()
                .Property(e => e.TEMPLATENAME)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_BATCHMSGTEMPLATE>()
                .Property(e => e.TEMPLATEVALUE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_BATCHMSGTEMPLATE>()
                .Property(e => e.PARMNUM)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSGTEMPLATE>()
                .Property(e => e.SENDSTR)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_BATCHMSGTEMPLATE>()
                .Property(e => e.CILENTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_BATCHMSGTEMPLATE>()
                .Property(e => e.TEMPLATELEN)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_BATCHMSGTEMPLATE>()
                .Property(e => e.SUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_FROMEMAIL>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_FROMEMAIL>()
                .Property(e => e.TRADECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_FROMEMAIL>()
                .Property(e => e.EMAIL_CONTENT)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_FROMEMAIL>()
                .Property(e => e.IS_SEND)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_FROMEMAIL>()
                .Property(e => e.TRADEPWD)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_FROMEMAIL>()
                .Property(e => e.RESID)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MESSAGE>()
                .Property(e => e.MESSAGEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MESSAGE>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MESSAGE>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MESSAGE>()
                .Property(e => e.SUBTYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MESSAGE>()
                .Property(e => e.CLIENTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MESSAGE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MESSAGE_HIS>()
                .Property(e => e.MESSAGEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MESSAGE_HIS>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MESSAGE_HIS>()
                .Property(e => e.SUBTYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MESSAGE_HIS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MESSAGE_HIS>()
                .Property(e => e.CLIENTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MESSAGE_HIS>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MESSAGE_HIS>()
                .Property(e => e.SENDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MOBILEPOPULAR>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MOBILEPOPULAR>()
                .Property(e => e.BATCHID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MOBILEPOPULAR>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MOBILEPOPULAR>()
                .Property(e => e.NUMENCRY)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MOBILEPOPULAR>()
                .Property(e => e.CLICKCOUNT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MOBILEPOPULARDETAIL>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MOBILEPOPULARDETAIL>()
                .Property(e => e.POPUID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGSUBTYPE>()
                .Property(e => e.SUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGSUBTYPE>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MSGSUBTYPE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGSUBTYPE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGSUBTYPE>()
                .Property(e => e.SUBTYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MSGSUBTYPE>()
                .HasMany(e => e.SMS_MSGTEMPLATE)
                .WithRequired(e => e.SMS_MSGSUBTYPE)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<SMS_MSGSUBTYPE>()
                .HasMany(e => e.SMS_MSGTYPE_CLIENT)
                .WithRequired(e => e.SMS_MSGSUBTYPE)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<SMS_MSGTEMPLATE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGTEMPLATE>()
                .Property(e => e.SUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGTEMPLATE>()
                .Property(e => e.AUDITORID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGTEMPLATE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGTEMPLATE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGTYPE>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MSGTYPE_CLIENT>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGTYPE_CLIENT>()
                .Property(e => e.SUBTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGTYPE_CLIENT>()
                .Property(e => e.TYPECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MSGTYPE_CLIENT>()
                .Property(e => e.CLIENTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_MSGTYPE_CLIENT>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_MSGTYPE_CLIENT>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_SENDLOG>()
                .Property(e => e.SENDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_SENDLOG>()
                .Property(e => e.CLIENTCODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_SENDLOG>()
                .Property(e => e.MSGSOURCEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_USERVERIFYCODE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SMS_USERVERIFYCODE>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_USERVERIFYCODE>()
                .Property(e => e.VERIFYRESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SMS_USERVERIFYCODE>()
                .Property(e => e.VERIFYCODE)
                .IsUnicode(false);

            modelBuilder.Entity<SMS_USERVERIFYCODE>()
                .Property(e => e.VERIFYTYPE)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ACTIVE>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVE>()
                .Property(e => e.PRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ACTIVE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVE>()
                .HasMany(e => e.SOFT_ACTIVEMODULE)
                .WithRequired(e => e.SOFT_ACTIVE)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<SOFT_ACTIVEDETAIL>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEDETAIL>()
                .Property(e => e.ORDERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEDETAIL>()
                .Property(e => e.MODULEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEDETAIL>()
                .Property(e => e.DAYS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEMODULE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEMODULE>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEMODULE>()
                .Property(e => e.MODULEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEMODULE>()
                .Property(e => e.DAYS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEMODULE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEMODULE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.ORDERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.PRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.ORDERSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.ORDERTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.OPENUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.CANCELUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.MEMO)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEORDER>()
                .Property(e => e.WEBORDERID)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ACTIVEREVAPPLY>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEREVAPPLY>()
                .Property(e => e.ORDERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEREVAPPLY>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ACTIVEREVAPPLY>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ACTIVEREVAPPLY>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEREVAPPLY>()
                .Property(e => e.PRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ACTIVEREVAPPLY>()
                .Property(e => e.APPLYERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEREVAPPLY>()
                .Property(e => e.CHECKERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEREVAPPLY>()
                .Property(e => e.ISCHECK)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ACTIVEREVAPPLY>()
                .Property(e => e.ISDELETE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ALLOCATERESLOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ALLOCATERESLOG>()
                .Property(e => e.SOFTNAME)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ALLOCATERESLOG>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_ALLOCATERESLOG>()
                .Property(e => e.ALLOCATETYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ALLOCATERESLOG>()
                .Property(e => e.SALESTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ALLOCATERESLOG>()
                .Property(e => e.ORGSALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ALLOCATERESLOG>()
                .Property(e => e.NEWSALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ALLOCATERESLOG>()
                .Property(e => e.OPUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_ALLOCATERESLOG>()
                .Property(e => e.OPREMART)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_CUSTOMER>()
                .Property(e => e.CUSTOMERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_CUSTOMER>()
                .Property(e => e.SOFTNAME)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_CUSTOMER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_CUSTOMER>()
                .Property(e => e.REGCAMPAINID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_CUSTOMER>()
                .Property(e => e.USERNO)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_CUSTOMER>()
                .Property(e => e.IDCARD)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_CUSTOMER>()
                .Property(e => e.SOFTTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_CUSTOMER>()
                .Property(e => e.PRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_CUSTOMER>()
                .Property(e => e.USERSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_CUSTOMER>()
                .Property(e => e.SALEUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.IMPORPTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.SOFTNAME)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.REGCAMPAINID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.USERNO)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.IDCARD)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.SOFTTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.PRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.USERSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.SALEUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_IMPORT_CUSTOMER>()
                .Property(e => e.MOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_JUEJINACTIVITYCONFIG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_JUEJINACTIVITYCONFIG>()
                .Property(e => e.VERIFICODE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_JUEJINACTIVITYCONFIG>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_JUEJINRES>()
                .Property(e => e.ID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_JUEJINRES>()
                .Property(e => e.NAME)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_JUEJINRES>()
                .Property(e => e.USERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_JUEJINRES>()
                .Property(e => e.CREATETIME)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_JUEJINRES>()
                .Property(e => e.EMAIL)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_JUEJINRES>()
                .Property(e => e.RESID)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_JUEJINRES>()
                .Property(e => e.VERIFICODE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_MODULE>()
                .Property(e => e.MODULEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_MODULE>()
                .Property(e => e.MODULENAME)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_MODULE>()
                .Property(e => e.DEFAULTDAYS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_MODULE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_MODULE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_MODULE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_PRODUCT>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_PRODUCT>()
                .Property(e => e.BIGPRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_PRODUCT>()
                .Property(e => e.PRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_PRODUCT>()
                .Property(e => e.DAYS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_REMOTECODE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_REMOTECODE>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_REMOTECODE>()
                .Property(e => e.REMOTECODE)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_REMOTECODE>()
                .Property(e => e.REMARK)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_REMOTECODE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_USER>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_USER>()
                .Property(e => e.USERPASS)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_USER>()
                .Property(e => e.USERNO)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_USER>()
                .Property(e => e.USERLEVEL)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_USER>()
                .Property(e => e.REGCAMPAINID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_USER>()
                .Property(e => e.REGPLATFORM)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_USER>()
                .Property(e => e.ACTIVERESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_USER>()
                .Property(e => e.ACTCAMPAINID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_USER>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_USER>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.BRANDLIST)
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.BRANDLISTVERSION)
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.BRANDLISTCONTENT)
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.BRANDFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.UPDATETIME)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.HADALERT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.ACCEPTTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.TYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.STATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.ENTERPRISEFATHER)
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.KFWORKERID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.SPECIALTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.ATTRSYNCVERSION)
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.INCREMENTUPDATETIME)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.BITFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.ALIAS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.NICKNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.CONREMARK)
                .IsUnicode(false);

            modelBuilder.Entity<WX_BIZINFO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<WX_DBRECIVE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_DBRECIVE>()
                .Property(e => e.DATATYPE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_DBRECIVE>()
                .Property(e => e.FILEPATH)
                .IsUnicode(false);

            modelBuilder.Entity<WX_DBRECIVE>()
                .Property(e => e.STATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_FILEPATH>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_FILEPATH>()
                .Property(e => e.MD5SERIALNUM)
                .IsUnicode(false);

            modelBuilder.Entity<WX_FILEPATH>()
                .Property(e => e.URL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_INNERUSERJOBNUM>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_INNERUSERJOBNUM>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_INNERUSERJOBNUM>()
                .Property(e => e.WXUSERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_INNERUSERJOBNUM>()
                .Property(e => e.WXNUMBER)
                .IsUnicode(false);

            modelBuilder.Entity<WX_INNERUSERJOBNUM>()
                .Property(e => e.STARTDATE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_INNERUSERJOBNUM>()
                .Property(e => e.ENDDATE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.BRANDLIST)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.BRANDLISTVERSION)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.BRANDLISTCONTENT)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.BRANDFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.EXTINFO)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.BRANDINFO)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.BRANDICONURL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.UPDATETIME)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.HADALERT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.ACCEPTTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.TYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.STATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.ENTERPRISEFATHER)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.KFWORKERID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.SPECIALTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.ATTRSYNCVERSION)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.INCREMENTUPDATETIME)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.BITFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.ALIAS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.MOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.NICKNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.CONREMARK)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.UIN)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.WEIXINSTRPATH)
                .IsUnicode(false);

            modelBuilder.Entity<WX_JOBBIZINFO>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.MSGID)
                .HasPrecision(22, 0);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.MSGSVRID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.ISSHOWTIMER)
                .HasPrecision(20, 0);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.CREATETIME)
                .HasPrecision(20, 0);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.TALKER)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.IMGPATH)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.RESERVED)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.LVBUFFER)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.TRANSCONTENT)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.TRANSBRANDWORDING)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.TALKERID)
                .HasPrecision(22, 0);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.BIZCLIENTMSGID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.BIZCHATID)
                .HasPrecision(22, 0);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.BIZCHATUSERID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.MSGSEQ)
                .HasPrecision(22, 0);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.NICKNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGE>()
                .Property(e => e.MSG_URL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                            .Property(e => e.JOBWXUSERNAME)
                            .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.ALIAS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.CONREMARK)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.DOMAINLIST)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.NICKNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.PYINITIAL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.QUANPIN)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.SHOWHEAD)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.TYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.WEIBOFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.WEIBONICKNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.CONREMARKPYFULL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.CONREMARKPYSHORT)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.LVBUFF)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.VERFYFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.ENCRYPTUSERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.CHATROOMFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.DELETEFLAG)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.CONTACTLABELIDS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<WX_RCONTACT>()
                .Property(e => e.RESID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_GROUPPERCENT>()
                .Property(e => e.GID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_GROUPPERCENT>()
                .Property(e => e.DIV_PERCENT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SETPERCENTLOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SETPERCENTLOG>()
                .Property(e => e.OPUSER)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SETPERCENTLOG>()
                .Property(e => e.OPDETAIL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_UINCONFIG>()
                .Property(e => e.UIN)
                .IsUnicode(false);

            modelBuilder.Entity<WX_UINCONFIG>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_UINCONFIG>()
                .Property(e => e.WX_PATH)
                .IsUnicode(false);

            modelBuilder.Entity<WX_USERPERCENT>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_USERPERCENT>()
                .Property(e => e.GID)
                .HasPrecision(38, 0);


            modelBuilder.Entity<WX_USERPERCENT>()
                .Property(e => e.DIV_PERCENT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_MEMOID_DELETE>()
                .Property(e => e.MEMOID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_MEMOID_DELETE>()
                .Property(e => e.BATCHID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CACHE_MEMOID_DELETE>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CACHE_MEMOID_DELETE>()
                .Property(e => e.MEMOCONTENTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<CSVR_CALLOUTPARA>()
                .Property(e => e.CALLOUTTYPE)
                .IsUnicode(false);

            modelBuilder.Entity<CSVR_CALLOUTPARA>()
                .Property(e => e.CALLOUTNUM)
                .IsUnicode(false);

            modelBuilder.Entity<IMP_RESIMPORTID>()
                .Property(e => e.IMPORTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<IMP_RESIMPORTID>()
                .Property(e => e.IMPORTDATA)
                .IsUnicode(false);

            modelBuilder.Entity<EXP_RESIMPORTID>()
                .Property(e => e.IMPORTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<EXP_RESIMPORTID>()
                .Property(e => e.IMPORTDATA)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMER_CSH>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMER_CSH>()
                .Property(e => e.CUSTOMERID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMER_CSH>()
                .Property(e => e.CUSTOMERFROM)
                .IsUnicode(false);

            modelBuilder.Entity<RES_CUSTOMER_CSH>()
                .Property(e => e.LASTNUM3)
                .IsUnicode(false);

            modelBuilder.Entity<RES_IMPORTRES_DETAIL>()
                .Property(e => e.IMPORTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_IMPORTRES_DETAIL>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_IMPORTRES_DETAIL>()
                .Property(e => e.MOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_IMPORTRES_DETAIL>()
                .Property(e => e.ENMOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_POOLLOG_HIS>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG_HIS>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_POOLLOG_HIS>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG_HIS>()
                .Property(e => e.ACTIVITYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG_HIS>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG_HIS>()
                .Property(e => e.APPLYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOG_HIS>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_POOLLOG_HIS>()
                .Property(e => e.DATATYPE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_POOLLOGBAK_20151130>()
                .Property(e => e.LOGID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOGBAK_20151130>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_POOLLOGBAK_20151130>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOGBAK_20151130>()
                .Property(e => e.ACTIVITYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOGBAK_20151130>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOGBAK_20151130>()
                .Property(e => e.APPLYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_POOLLOGBAK_20151130>()
                .Property(e => e.RESOURCETAG)
                .IsUnicode(false);

            modelBuilder.Entity<RES_POOLLOGBAK_20151130>()
                .Property(e => e.DATATYPE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCEMOBILE_BAK>()
                .Property(e => e.RESID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCEMOBILE_BAK>()
                .Property(e => e.MOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCEMOBILE_BAK>()
                .Property(e => e.ISMOBILE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCEMOBILE_BAK>()
                .Property(e => e.ENMOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCETYPE_20160121>()
                .Property(e => e.RESTYPEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCETYPE_20160121>()
                .Property(e => e.RESTYPECODE)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCETYPE_20160121>()
                .Property(e => e.COMPANYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCETYPE_20160121>()
                .Property(e => e.BUSINESSCODE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_RESOURCETYPE_20160121>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCETYPE_20160121>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_RESOURCETYPE_20160121>()
                .Property(e => e.ATTRIBUTE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_BIGPRODUCT>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_BIGPRODUCT>()
                .Property(e => e.PRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_BIGPRODUCT>()
                .Property(e => e.USECLIENT)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_MODULE_TG>()
                .Property(e => e.MODULEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_MODULE_TG>()
                .Property(e => e.MODULENAME)
                .IsUnicode(false);

            modelBuilder.Entity<SOFT_MODULE_TG>()
                .Property(e => e.DEFAULTDAYS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_MODULE_TG>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_MODULE_TG>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_MODULE_TG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_PRODUCTMODULE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_PRODUCTMODULE>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_PRODUCTMODULE>()
                .Property(e => e.MODULEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_PRODUCTMODULE>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<SOFT_PRODUCTMODULE>()
                .Property(e => e.UPDATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<VIEW_RES_DISTRIBUTE>()
                .Property(e => e.DISTRIBUTEID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<VIEW_RES_DISTRIBUTE>()
                .Property(e => e.SALESID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLOCATESTRATEGY>()
                .Property(e => e.STRATEGYID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLOCATESTRATEGY>()
                .Property(e => e.SALESGROUPID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLOCATESTRATEGY>()
                .Property(e => e.CHECKPROCEDURE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_ALLOCATESTRATEGY>()
                .Property(e => e.ALLCOTEPROCEDURE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_ALLOCATESTRATEGY>()
                .Property(e => e.RECYCLEPROCEDURE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_ALLOCATESTRATEGY>()
                .Property(e => e.VIEWPROCEDURE)
                .IsUnicode(false);

            modelBuilder.Entity<RES_ALLOCATESTRATEGY>()
                .Property(e => e.CREATEUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_ALLOCATESTRATEGY>()
                .Property(e => e.STRATEGYNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.ALIAS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.QRCODEURL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.MOBILE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.RESID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.AUDITSTATAUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.AUDITMEMO)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.AUDITUSER)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.ISVALID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.QRCODESIZE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT_INIT>()
                .Property(e => e.QUANTITY)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.ORDERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.EMPLOYEEID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.PASSWORD)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.USERID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.PRODUCTNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.SUBPRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.SUBPRODUCTNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.ORDERTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.UPGRADEORDERIDS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.TOTALUPGRADEVALUE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.NEEDPAY)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.OPENORDER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.SZZYORDERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.ORDERSTATUS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.RETURNNEEDPAY)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.CONTRACTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.RET)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.MSG)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.RETURNDETAIL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.RESID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.REQUESTSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.REMARK)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.FINALPAY)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.ORDERSTATUSNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.STIME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.ETIME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.SUSPENDCOMMENT)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.ISOPEN)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.TEAMSERVE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.FCTEXT)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.CUSTOMERUSERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.ARRIVALPAY)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.SOURCE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.CNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYORDER>()
                .Property(e => e.OPENDAYS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYPRODUCT>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYPRODUCT>()
                .Property(e => e.PRODUCTNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYPRODUCT>()
                .Property(e => e.PRODUCTDESC)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYPRODUCT>()
                .Property(e => e.PRODUCTBRIEFDESC)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYPRODUCT>()
                .Property(e => e.ISVALID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYPRODUCT>()
                .Property(e => e.PRODUCTGUIDE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYPRODUCT>()
                .Property(e => e.PRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.SUBPRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.SUBPRODUCTNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.SUBPRODUCTDESC)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.PRICE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.RIGHTPERIOD)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.RIGHTUNIT)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.ISVALID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.ORDEROPENTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.OPENDATE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.ENDDATE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.PRODUCTALIAS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SZZYSUBPRODUCT>()
                .Property(e => e.PRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_USERIMEI>()
                .Property(e => e.IMEI)
                .IsUnicode(false);

            modelBuilder.Entity<WX_USERIMEI>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_NOTICE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_NOTICE>()
                .Property(e => e.TITLE)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_NOTICE>()
                .Property(e => e.CONTENT)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_NOTICE>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ARRIVALPAYLOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ARRIVALPAYLOG>()
                .Property(e => e.SZZYORDERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ARRIVALPAYLOG>()
                .Property(e => e.ARRIVALPAY)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);


            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
                .Property(e => e.ALIAS)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
                .Property(e => e.NICKNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
               .Property(e => e.INNERUSERID)
               .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
               .Property(e => e.PAUSETYPE)
               .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
            .Property(e => e.ISVALID)
            .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
                .Property(e => e.MEMO)
                .IsUnicode(false);

            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
                .Property(e => e.PAUSEREASON)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
                .Property(e => e.OPERATERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_SYSTEMPAUSELOG>()
               .Property(e => e.DURMINUTE)
               .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT_ONLINELOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT_ONLINELOG>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_WORKACCOUNT_ONLINELOG>()
                .Property(e => e.ALIVENUM)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_WORKACCOUNT_ONLINELOG>()
                .Property(e => e.ONLINERATE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MOBILEQUERYLOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MOBILEQUERYLOG>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<RES_MOBILEQUERYLOG>()
                .Property(e => e.RESID)
                .IsUnicode(false);

            modelBuilder.Entity<RES_MOBILEQUERYLOG>()
                .Property(e => e.IP)
                .IsUnicode(false);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.ORDERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.NAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.SOFTUSERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.ISPAYED)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.PAYTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.PAYNO)
                .IsUnicode(false);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.OPENDAYS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.AUDITUSER)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.APPUSERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.PRODUCTID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.PRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.BIGPRODUCTCODE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_ORDEREXT>()
               .Property(e => e.CHANNEL)
               .IsUnicode(false);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.BOOKNUM)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.ORDERSTATUS)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ORDEREXT>()
                .Property(e => e.ORDERSOURCE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_ORDEREXT>()
               .Property(e => e.OPENUSER)
               .IsUnicode(false);

            modelBuilder.Entity<QC_COMPLAIN_SERVICEMEMO>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_COMPLAIN_SERVICEMEMO>()
                .Property(e => e.COMPLAINID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_COMPLAIN_SERVICEMEMO>()
                .Property(e => e.RECOMPLAINLEVEL)
                .IsUnicode(false);

            modelBuilder.Entity<QC_COMPLAIN_SERVICEMEMO>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<QC_COMPLAIN_SERVICEMEMO>()
                .Property(e => e.MEMO)
                .IsUnicode(false);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.REFERRERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.STOCKCODE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.STOCKNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.BUYPRICE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.STOPLOSSPRICE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.POSITION)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.SELLDATEANDPRICE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.EARNINGRATE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.RECOMMENDREASON)
                .IsUnicode(false);

            modelBuilder.Entity<WX_STOCKRECOMMEND>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_AFTERSALES_LOG>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_AFTERSALES_LOG>()
                .Property(e => e.RESID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_AFTERSALES_LOG>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_AFTERSALES_LOG>()
                .Property(e => e.OPERATORID)
                .HasPrecision(38, 0);


            modelBuilder.Entity<BAS_FEEDBACK>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_FEEDBACK>()
                .Property(e => e.CONTENT)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_FEEDBACK>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_FEEDBACK>()
                .Property(e => e.SHOWTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<BAS_FEEDBACK>()
                .Property(e => e.REPLY)
                .IsUnicode(false);

            modelBuilder.Entity<BAS_FEEDBACK>()
                .Property(e => e.REPLYERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.PKID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.JOBUSERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.USERNAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.INNERUSERID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.MESSAGE)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.OPERATORID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.MSGTYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.MSGSOURCE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.MSGSVRID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.MSGURL)
                .IsUnicode(false);

            modelBuilder.Entity<WX_UNLINE_NOTICECONFIG>()
               .Property(e => e.PKID)
               .HasPrecision(38, 0);

            modelBuilder.Entity<WX_UNLINE_NOTICECONFIG>()
                .Property(e => e.EID)
                .HasPrecision(38, 0);


            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.TYPE)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.RECORDID)
                .HasPrecision(38, 0);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.SERVERID)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.FILENAME)
                .IsUnicode(false);

            modelBuilder.Entity<WX_MESSAGECOMPLIANCE>()
                .Property(e => e.RESID)
                .IsUnicode(false);

        }
    }
}