namespace wcftest.orm
{
    using System;
    using System.Data.Entity;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Linq;
    using wcftest.orm_test;

    public partial class dbModel : DbContext
    {
        public dbModel()
            : base("name=dbModel")
        {
        }
        public virtual DbSet<Purchase_OrderList_EmptyMaterialCode> Purchase_OrderList_EmptyMaterialCode { get; set; }
        public virtual DbSet<Base_PositionPrint> Base_PositionPrint { get; set; }
        public virtual DbSet<Sale_Order_History_Items> Sale_Order_History_Items { get; set; }
        public virtual DbSet<Sale_Order_History> Sale_Order_History { get; set; }
        public virtual DbSet<Wms_FreeTimeMoveLocationTaskDetails> Wms_FreeTimeMoveLocationTaskDetails { get; set; }
        public virtual DbSet<Sys_RoleAuth> Sys_RoleAuth { get; set; }
        public virtual DbSet<Base_Position> Base_Position { get; set; }
        public virtual DbSet<Base_ProductPosition> Base_ProductPosition { get; set; }
        public virtual DbSet<ContainerIsFullOrEmpty> ContainerIsFullOrEmpty { get; set; }
        public virtual DbSet<Purchase_Shelve> Purchase_Shelve { get; set; }
        public virtual DbSet<Purchase_ShelveList> Purchase_ShelveList { get; set; }
        public virtual DbSet<Sale_Order> Sale_Order { get; set; }
        public virtual DbSet<Sale_OrderList> Sale_OrderList { get; set; }
        public virtual DbSet<Sys_User> Sys_User { get; set; }
        public virtual DbSet<Task_Queue> Task_Queue { get; set; }
        public virtual DbSet<vvBase_ProductPosition> vvBase_ProductPosition { get; set; }
        public virtual DbSet<vvBase_ProductPosition_all> vvBase_ProductPosition_all { get; set; }
        public virtual DbSet<sortingList> sortingList { get; set; }
        //public virtual DbSet<containerType11> containerType11 { get; set; }
        public virtual DbSet<Base_Equipment> Base_Equipment { get; set; }
        public virtual DbSet<Base_Plate> Base_Plate { get; set; }
        public virtual DbSet<Purchase_Order> Purchase_Order { get; set; }
        public virtual DbSet<Purchase_OrderList> Purchase_OrderList { get; set; }
        public virtual DbSet<Base_ProductInfo> Base_ProductInfo { get; set; }
        public virtual DbSet<lackOrder> lackOrder { get; set; }
        public virtual DbSet<lackOrderList> lackOrderList { get; set; }
        public virtual DbSet<SapSendInfo> SapSendInfo { get; set; }
        public virtual DbSet<TakeStock> TakeStock { get; set; }
        public virtual DbSet<deviceGeneralInfo> deviceGeneralInfo { get; set; }
        public virtual DbSet<deviceGeneralInfoForDetail> deviceGeneralInfoForDetail { get; set; }
        public virtual DbSet<Sys_User_Log> Sys_User_Log { get; set; }
        public virtual DbSet<OutInStockTask> OutInStockTask { get; set; }
        public virtual DbSet<VmaterialInfo> VmaterialInfo { get; set; }

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

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

        public virtual DbSet<Base_BasicDataSet> Base_BasicDataSet { get; set; }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Purchase_OrderList_EmptyMaterialCode>()
                .Property(e => e.Quantity)
                .HasPrecision(18, 0);

            modelBuilder.Entity<Purchase_OrderList_EmptyMaterialCode>()
                .Property(e => e.Creator)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_OrderList_EmptyMaterialCode>()
                .Property(e => e.LastModifier)
                .IsUnicode(false);

            modelBuilder.Entity<Base_PositionPrint>()
               .Property(e => e.ProductStorage)
               .HasPrecision(14, 4);

            modelBuilder.Entity<Base_PositionPrint>()
                .Property(e => e.TotalWeight)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_PositionPrint>()
                .Property(e => e.Quantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Order_History_Items>()
               .Property(e => e.QuantityOrder)
               .HasPrecision(12, 4);

            modelBuilder.Entity<Sale_Order_History_Items>()
                .Property(e => e.LackQuantity)
                .HasPrecision(12, 4);

            modelBuilder.Entity<Sale_Order_History_Items>()
                .Property(e => e.TemporaryQuantity)
                .HasPrecision(12, 4);

            modelBuilder.Entity<Sale_Order_History_Items>()
                .Property(e => e.Creator)
                .IsUnicode(false);

            modelBuilder.Entity<Sale_Order_History_Items>()
                .Property(e => e.LastModifier)
                .IsUnicode(false);

            modelBuilder.Entity<Sale_Order_History>()
             .Property(e => e.Creator)
             .IsUnicode(false);

            modelBuilder.Entity<Sale_Order_History>()
                .Property(e => e.LastModifier)
                .IsUnicode(false);

            modelBuilder.Entity<Wms_FreeTimeMoveLocationTaskDetails>()
              .Property(e => e.Creator)
              .IsUnicode(false);

            modelBuilder.Entity<Wms_FreeTimeMoveLocationTaskDetails>()
                .Property(e => e.LastModifier)
                .IsUnicode(false);

            modelBuilder.Entity<SapSendFailRecodInfo>()
               .Property(e => e.Creator)
               .IsUnicode(false);

            modelBuilder.Entity<SapSendFailRecodInfo>()
                .Property(e => e.LastModifier)
                .IsUnicode(false);

            modelBuilder.Entity<SapSendInfo>()
                .Property(e => e.Quantity)
                .HasPrecision(10, 2);

            modelBuilder.Entity<Base_Position>()
                .Property(e => e.PlateCode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.DynamicWeight)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.ProductStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.OrignStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.PurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.Rate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.AvgPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.Weight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Base_ProductPosition>()
                .Property(e => e.TotalWeightOrign)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.ShelveCode)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.ShelveType)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.PositionName)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.StorageName)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.UserTrueName)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.SpanTime)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.TotalQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.OnShelveQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.ShelvedQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.DynamicWeight)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Shelve>()
                .Property(e => e.PlateCode)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.ProductCode)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.ProductName)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.ProductModel)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.Quantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.PositionName)
                .IsUnicode(false);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.OnShelveQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.ShelvedQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.Rate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_ShelveList>()
                .Property(e => e.PurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalQuantityOrder)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalQuantityCanceled)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalQuantityInvoiced)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalQuantityRefunded)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalQuantityOuted)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalQuantityShipped)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.Weight)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.MaterialCount)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseTaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseDiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseSubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseGrandTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseTotalPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseTotalUnPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseTotalRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseTotalCanceled)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseTotalInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseTotalOnlineRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseTotalOffRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.ShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.FactFreightRMB)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.DiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.GrandTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.Unpaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalCanceled)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalOnlineRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalOffRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.StoreBaseRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.StoreOrderRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseGlobalRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.BaseOrderRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.FavourAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalRateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.ValidQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Order>()
                .Property(e => e.OutNumber)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.QuantityOrder)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.QuantityRefunded)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.QuantityOuted)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.QuantityShipped)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseSalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseOriginalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseTaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseTaxInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseDiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseDiscountInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseAmountRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseSubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseRowTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseRowInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseTaxBeforeDiscount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.Rate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseRatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BaseRateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.TaxBeforeDiscount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.SalePriceDiscount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.OriginalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.TaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.TaxInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.DiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.DiscountInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.AmountRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.RowTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.RowInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.LackStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.DiscountRate)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.ShippingAmount)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.RowPaid)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.AttachAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.BatchQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.RowWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.ValidQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderList>()
                .Property(e => e.PlanQty)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.LoginIP)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.Remark)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.Auditor)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.BasePay)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.DeductMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.SheBaoJiJin)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.MealSubsidy)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.CarSubsidy)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.CommSubsidy)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.EvecationSubsidy)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.OtherSubsidy)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.ServeFee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.ExpressFee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.SaleFee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.OtherFee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sys_User>()
                .Property(e => e.AgentID)
                .IsUnicode(false);

            modelBuilder.Entity<vvBase_ProductPosition>()
                   .Property(e => e.OrignStorage)
                   .HasPrecision(14, 4);

            modelBuilder.Entity<vvBase_ProductPosition>()
                .Property(e => e.ProductStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vvBase_ProductPosition_all>()
                 .Property(e => e.OrignStorage)
                 .HasPrecision(14, 4);

            modelBuilder.Entity<vvBase_ProductPosition_all>()
                .Property(e => e.ProductStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_Equipment>()
               .Property(e => e.SurplusQuantity)
               .HasPrecision(14, 4);
            modelBuilder.Entity<Base_Plate>()
               .Property(e => e.PlateCode)
               .IsUnicode(false);

            modelBuilder.Entity<Base_Plate>()
                .Property(e => e.Length)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_Plate>()
                .Property(e => e.Width)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_Plate>()
                .Property(e => e.Height)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_Plate>()
                .Property(e => e.PlateWeight)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_Plate>()
                .Property(e => e.PackingQuantity)
                .HasPrecision(14, 4);
            modelBuilder.Entity<Purchase_Order>()
              .Property(e => e.CorpURL)
              .IsUnicode(false);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.TotalQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.TotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.TotalPaidMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.SurplusTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.ExpressFee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.Rate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.TotalRateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.Refund)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.TaxAmountTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.TotalPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.Unpaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.DynamicWeight)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.TotalBigQty)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.TotalBigEnterQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Order>()
                .Property(e => e.TotalEnterQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Order>()
                .HasMany(e => e.Purchase_OrderList)
                .WithOptional(e => e.Purchase_Order)
                .WillCascadeOnDelete();

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

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.Quantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.PurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.Rate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.TaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.EnterQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.ReturnQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.MarketPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.DiscountRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.BigQty)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.TotalPackageQty)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.PaiQty)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.ValidQty)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.BigEnterQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.BigUnEnterQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_OrderList>()
                .Property(e => e.UnEnterQuantity)
                .HasPrecision(14, 4);
            modelBuilder.Entity<Base_ProductInfo>()
               .Property(e => e.PurchasePrice)
               .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.DayPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.VipPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.ActivityPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.StorageUpper)
                .HasPrecision(18, 0);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.StorageLower)
                .HasPrecision(18, 0);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.TransitDays)
                .HasPrecision(18, 0);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.Auditor)
                .IsUnicode(false);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.Weight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.SupplierUrl)
                .IsUnicode(false);

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

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.NetWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.QualityProportion)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.Cube)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.Rate)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.NoReceivingRate)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.MarketPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.PurchaseMoney)
                .HasPrecision(18, 0);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.TaxAmount)
                .HasPrecision(18, 0);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.StatutoryQty2)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.WeightTolerance)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.PlateCode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_ProductInfo>()
                .Property(e => e.PackingQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sys_User_Log>()
               .Property(e => e.Creator)
               .IsUnicode(false);

            modelBuilder.Entity<Sys_User_Log>()
                .Property(e => e.Modifier)
                .IsUnicode(false);

            modelBuilder.Entity<OutInStockTask>()
               .Property(e => e.quantity)
               .HasPrecision(18, 2);

            modelBuilder.Entity<Wms_FreeTimeMoveLocationTask>()
              .Property(e => e.Creator)
              .IsUnicode(false);

            modelBuilder.Entity<Wms_FreeTimeMoveLocationTask>()
                .Property(e => e.LastModifier)
                .IsUnicode(false);

            modelBuilder.Entity<Base_BasicDataSet>()
            .Property(e => e.Creator)
            .IsUnicode(false);

            modelBuilder.Entity<Base_BasicDataSet>()
                .Property(e => e.LastModifier)
                .IsUnicode(false);

        }
    }
}